Grasshopper 3D Resources

Loft

Inputs: Curves (Curve), Options (Loft Options)

Outputs: Surface (Surface)

Generates a surface by interpolating between multiple curves.

Contour
Inputs: Geometry, Base Point (Point3d), Direction (Vector3d), Distance (Number)
Outputs: Curves (Curve)
Generates contour lines by intersecting geometry with planes spaced at regular intervals along a specified direction.

Extrude
Inputs: Base Curve/Surface (Curve/Surface), Direction (Vector3d)
Outputs: Extrusion (Surface)
Extrudes a curve or surface along a specified direction to create a 3D form.

Custom Preview
Inputs: Geometry (Geometry), Material/Color (Material/Color)
Outputs: Display Preview (Geometry)
Displays geometry in the Rhino viewport with a specified material or color, allowing for customized visual feedback during modeling.

Flatten Tree
Inputs: Tree (Data Tree)
Outputs: Flattened Tree (List)
Converts a data tree with multiple branches into a single, flat list, removing all hierarchical structure.

Circle
Inputs: Base Plane (Plane), Radius (Number)
Outputs: Circle (Curve)
Generates a circle based on a specified plane and radius.

Divide Curve
Inputs: Curve (Curve), Count (Integer)
Outputs: Points (Point3d), Parameters (Number)
Divides a curve into a specified number of equal segments, returning the division points and their corresponding curve parameters.

Cap Holes
Inputs: Open Brep (Brep)
Outputs: Capped Brep (Brep)
Seals the open edges of a Brep by creating planar surfaces, effectively closing any holes to form a solid object.

Solid Difference
Inputs: A (Brep), B (Brep)
Outputs: Difference (Brep)
Subtracts one solid (B) from another solid (A), resulting in the remaining portion of solid A after the subtraction.

Move
Inputs: Geometry (Geometry), Translation Vector (Vector3d)
Outputs: Moved Geometry (Geometry)
Translates geometry from its original location to a new position along a specified vector.

Solid Union
Inputs: All (Brep)
Outputs: Union (Brep)
Combines two or more solid Breps into a single unified Brep by merging their overlapping volumes.

Edge from Direction
Inputs: Brep (Brep), Direction (Vector3d), Reflex (Boolean), Angle (Number)
Outputs: Edge Indices (Integer List)
Identifies and extracts edges from a Brep that align with a specified direction, considering angle and reflex criteria for precise edge selection.

Region Union
Inputs: Regions (Curve), Plane (Optional)
Outputs: Unioned Region (Curve)
Combines multiple 2D regions (closed curves) into a single region by merging overlapping areas.

Fillet Edge
Inputs: Brep (Brep), Blend (G0, G1 & G2), Radius (Number), Edge Index (Integer)
Outputs: Filleted Brep (Brep)
Rounds the specified edges of a Brep by applying a fillet with a given radius, creating smooth transitions between adjacent surfaces.

Deconstruct Brep
Inputs: Brep (Brep)
Outputs: Faces (Surface), Edges (Curve), Vertices (Point3d)
Breaks down a Brep into its constituent parts, including faces, edges, and vertices, allowing for individual manipulation or analysis.

List Item
Inputs: List (List), Index (Integer)
Outputs: Item (Data)
Retrieves an item from a list based on its index position, allowing access to specific elements within a list.

Series
Inputs: Start (Number), Step (Number), Count (Integer)
Outputs: Numbers (List of Numbers)
Generates a sequence of numbers starting from a specified value, incrementing by a set step, and continuing for a defined count.

Point on Curve
Inputs: Curve (Curve), Parameter (Number)
Outputs: Point (Point3d)
Evaluates a point on a curve at a specified parameter, typically between 0 and 1, where 0 represents the start of the curve and 1 the end.

Evaluate Curve
Inputs: Curve (Curve), Parameter (Number)
Outputs: Point (Point3d), Tangent (Vector), Curvature (Vector)
Evaluates a curve at a specified parameter, returning the point on the curve, the tangent vector, and the curvature at that point.

Rotate
Inputs: Geometry (Geometry), Angle (Number), Axis (Vector/Line/Point)
Outputs: Rotated Geometry (Geometry)
Rotates geometry around a specified axis by a given angle, allowing for controlled transformations in 2D or 3D space.

Polygon
Inputs: Plane (Plane), Radius (Number), Sides (Integer)
Outputs: Polygon (Curve)
Generates a regular polygon on a specified plane with a given radius and number of sides.

Evaluate Surface
Inputs: Surface (Surface), UV (Point2d)
Outputs: Point (Point3d), Normal (Vector), Frame (Plane), Curvature (Vector)
Evaluates a surface at specified UV coordinates, returning the point on the surface, the normal vector, the local plane (frame), and the curvature at that point.

MD Slider
Inputs: None (User interaction directly on the canvas)
Outputs: Point (Point2d)
An interactive slider that allows users to select a point within a 2D domain (UV space), outputting the selected point's UV coordinates.

Rebuild Curve
Inputs: Curve (Curve), Point Count (Integer), Degree (Integer)
Outputs: Rebuilt Curve (Curve)
Reconstructs a curve with a specified number of control points and a defined degree, creating a smoother or more refined version of the original curve.

Graft Tree
Inputs: Data (Any Data Type)
Outputs: Grafted Data Tree (Data Tree)
Transforms each item in a data tree into its own branch, effectively increasing the hierarchy level and isolating individual items into separate branches.

Entwine
Inputs: Data (Any Data Type, Multiple Inputs)
Outputs: Combined Data Tree (Data Tree)
Merges multiple inputs into a single data tree, organizing each input into a separate branch while preserving the structure of the individual data streams.

Hexagonal
Inputs: Plane (Plane), Radius (Number), Extents (Integer, Integer)
Outputs: Hexagons (Curves)
Generates a grid of hexagons on a specified plane, based on the provided radius and grid extents, useful for creating tiling patterns.

Merge
Inputs: Data (Any Data Type, Multiple Inputs)
Outputs: Merged List (List)
Combines multiple data streams into a single list, preserving the input order and merging them into a continuous sequence.

Tree Item
Inputs: Tree (Data Tree), Path (Path), Index (Integer)
Outputs: Item (Data)
Retrieves a specific item from a data tree based on the specified branch path and item index within that branch.

Tree Branch
Inputs: Tree (Data Tree), Path (Path)
Outputs: Branch (Data)
Extracts a specific branch from a data tree based on the provided path, returning all items within that branch.

Param Viewer
Inputs: Data (Any Data Type)
Outputs: Viewer (Graphic Display), Tree Structure (Text)
Visually displays the structure of a data tree, showing the number of branches and the distribution of items within each branch, providing a clear overview of complex data trees.

Range
Inputs: Domain (Domain), Steps (Integer)
Outputs: Numbers (List of Numbers)
Generates a sequence of numbers within a specified domain, dividing the domain into equal intervals based on the number of steps provided.

Larger Than
Inputs: A (Number), B (Number)
Outputs: Result (Boolean)
Compares two numbers and returns True if the first number (A) is larger than the second number (B), otherwise returns False.

Construct Domain
Inputs: Start (Number), End (Number)
Outputs: Domain (Domain)
Creates a numerical domain from a start value to an end value, defining a range that can be used in various mathematical and geometrical operations.

Dispatch
Inputs: List (List), Pattern (Boolean List)
Outputs: A (List), B (List)
Splits a list into two sub-lists based on a pattern of True and False values. Items corresponding to True go into list A, and items corresponding to False go into list B.

Image Sampler
Inputs: Point (Point2d), Image (Bitmap)
Outputs: Sampled Value (Color/Number)
Extracts color or brightness values from a specified image based on input points, enabling the creation of geometry influenced by image data.

Pull Point
Inputs: Points (Point3d), Geometry (Curve/Surface/Brep)
Outputs: Pulled Points (Point3d), Parameters (Number)
Projects points onto the closest location on a given geometry, such as a curve, surface, or Brep, returning the new positions and their corresponding parameters on the geometry.

Remap Numbers
Inputs: Values (Number List), Source Domain (Domain), Target Domain (Domain)
Outputs: Remapped Values (Number List)
Maps a list of numbers from an original domain to a new target domain, adjusting the values proportionally to fit within the new range.

Boundary Surface
Inputs: Curves (Curve)
Outputs: Surface (Surface)
Creates a surface from a closed boundary of curves, filling the region enclosed by the curves.

Graph Mapper
Inputs: Values (Number List)
Outputs: Mapped Values (Number List)
Transforms a list of numbers according to a user-defined graph, allowing for customized remapping of values based on various curve types (e.g., linear, bezier, sine).

Surface Frames
Inputs: Surface (Surface), UV Coordinates (Point2d/List)
Outputs: Planes (Plane)
Generates a grid of planes (frames) aligned to a surface at specified UV coordinates, useful for creating reference planes across a surface for further geometric operations.

Refine (Kangaroo)
Inputs: Mesh (Mesh), Level (Integer)
Outputs: Refined Mesh (Mesh)
This component refines a mesh by iteratively sub dividing each face into 4 faces.

Brep Join
Inputs: Breps (List of Breps)
Outputs: Joined Brep (Brep)
Combines multiple Breps into a single unified Brep by joining their adjacent edges, creating a seamless geometry if possible.

Simple Mesh
Inputs: Geometry (Brep/Surface)
Outputs: Mesh (Mesh)
Converts a given geometry into a simple mesh based on specified parameters, useful for visualizations and further mesh operations.

Diamond Panels (LunchBox)
Inputs: Surface (Surface), U Divisions (Integer), V Divisions (Integer)
Outputs: Diamond Panels (Mesh/Polylines)
Divides a surface into a grid of diamond-shaped panels by specifying the number of divisions along the U and V directions, commonly used for panelization in architectural design.

SubD from Mesh
Inputs: Mesh (Mesh)
Outputs: SubD (SubD)
Converts a mesh into a SubD (Subdivision Surface) object, allowing for smoother, more refined geometry suitable for further editing and refinement.