> ## Documentation Index > Fetch the complete documentation index at: https://docs.nodi3d.com/llms.txt > Use this file to discover all available pages before exploring further. # Nodes > Complete reference of all Nodi node components List of all the node components used in Nodi. ## Math **Operator** Calculate the absolute value of a number **Inputs** * input value : `Number` **Outputs** * output value : `Number` Add two numbers **Properties** * a : `Number` * b : `Number` **Inputs** * a : `Number, Complex, Point, Vector` * b : `Number, Complex, Point, Vector` **Outputs** * output : `Number, Complex, Point, Vector` Round a number up to the nearest integer **Inputs** * input value : `Number, Matrix, Point, Vector` **Outputs** * output value : `Number, Matrix, Point, Vector` Divide two numbers **Properties** * a : `Number` * b : `Number` **Inputs** * a : `Number, Complex, Point, Vector` * b : `Number, Complex, Point, Vector` **Outputs** * output : `Number, Complex, Point, Vector` Check if two values are equal **Inputs** * compare : `Any` * compare to : `Any` **Outputs** * equal : `Bool` * not equal : `Bool` Round a number down to the nearest integer **Inputs** * input value : `Number, Matrix, Point, Vector` **Outputs** * output value : `Number, Matrix, Point, Vector` Check if all inputs are true **Inputs** * 0th compare : `Number, Bool` * 1th compare : `Number, Bool` **Outputs** * result values : `Bool` Invert a boolean value **Inputs** * boolean value : `Number, Bool` **Outputs** * inverse of input : `Bool` Check if any of the input values are true **Inputs** * 0th compare : `Number, Bool` * 1th compare : `Number, Bool` **Outputs** * result values : `Bool` Check if a number is larger than another number **Inputs** * number to test : `Number` * number to test against : `Number` **Outputs** * `>` : `Bool` * `>=` : `Bool` Calculate the mass addition of a list of numbers **Inputs** * Input values for mass addition : `Number, Complex, Point, Vector` **Outputs** * results of mass addition : `Number, Complex, Point, Vector` * list of partial results : `Number, Complex, Point, Vector` Calculate the mass multiplication of a list of numbers **Inputs** * Input values for mass multiplication : `Number` **Outputs** * results of mass multiplication : `Number` * list of partial results : `Number` Calculate the remainder of a division **Properties** * divisor : `Number` **Inputs** * dividend : `Number` * divisor : `Number` **Outputs** * remainder : `Number` Multiply two numbers **Properties** * a : `Number` * b : `Number` **Inputs** * a : `Number, Complex, Point, Vector` * b : `Number, Complex, Point, Vector` **Outputs** * output : `Number, Complex, Point, Vector` Negate a value **Inputs** * input value : `Number, Bool, Domain, Matrix, Complex, Point, Vector` **Outputs** * negated value : `Number, Bool, Domain, Matrix, Complex, Point, Vector` Calculate the power of a number **Properties** * power : `Number` **Inputs** * input value : `Number` * the exponent : `Number` **Outputs** * output value : `Number` Round a number to a specified precision **Properties** * precision : `Number` **Inputs** * input value : `Number, Matrix, Point, Vector` * round precision : `Number` **Outputs** * output value : `Number, Matrix, Point, Vector` Check if a number is smaller than another **Inputs** * number to test : `Number` * number to test against : `Number` **Outputs** * `<` : `Bool` * `<=` : `Bool` Subtract two numbers **Properties** * a : `Number` * b : `Number` **Inputs** * a : `Number, Complex, Point, Vector` * b : `Number, Complex, Point, Vector` **Outputs** * output : `Number, Complex, Point, Vector` **Polynomials** Calculate the square of a number **Inputs** * input value : `Number` **Outputs** * output value : `Number` Calculate the square root of a number **Inputs** * input value : `Number` **Outputs** * output value : `Number` **Trigonometry** Calculate the arc cosine of a number **Inputs** * input : `Number` **Outputs** * arc cosine of input : `Number` Calculate the arc sine of a number **Inputs** * input : `Number` **Outputs** * arc sine of input : `Number` Calculate the arc tangent of a number **Inputs** * input : `Number` **Outputs** * arc tangent of input : `Number` Calculate the cosine of a number **Inputs** * input : `Number` **Outputs** * cosine of input : `Number` Converts an angle in radians to degrees **Properties** * value : `Number` **Inputs** * angle in radians : `Number` **Outputs** * angle in degrees : `Number` Convert degrees to radians **Properties** * value : `Number` **Inputs** * angle in degrees : `Number` **Outputs** * angle in radians : `Number` Calculate the sine of a number **Inputs** * input : `Number` **Outputs** * sine of input : `Number` Calculate the tangent of a number **Inputs** * input : `Number` **Outputs** * tangent of input : `Number` **Domain** Calculate the bounds of the input values **Inputs** * input values : `Number, Field` **Outputs** * resulting domain : `Domain` Calculate the consecutive domains between the input values **Properties** * sum total : `Bool` **Inputs** * numbers for consecutive domains : `Number` * if true * values are added to a sum-total : `Bool` **Outputs** * Domains describing the spaces between the numbers : `Domain` Construct a numeric domain from two values **Properties** * min : `Number` * max : `Number` **Inputs** * start value of numeric domain : `Number` * end value of numeric domain : `Number` **Outputs** * numeric domain : `Domain` Deconstruct a numeric domain into start and end values **Inputs** * base domain : `Domain` **Outputs** * start value of domain : `Number` * end value of domain : `Number` * domain size : `Number` Test if a value is included in a domain **Inputs** * value to test for inclusion : `Number` * domain to test with : `Domain` **Outputs** * true if the value is included in the domain : `Bool` * distance between the value and the nearest value inside the domain : `Number` Remap a number from one domain to another **Properties** * source : `Vector2d` * destination : `Vector2d` **Inputs** * value to remap : `Number, Field` * source domain : `Domain` * target domain : `Domain` **Outputs** * remapped value : `Number, Field` **Script** Call a function with arguments. Supports Number, Vector, Point inputs. **Inputs** * function : `Function` * arg\[0] : `Any` **Outputs** * result : `Any` * log : `String` Create a callable function using Rhai scripting. Capture textures and parameters as IN\[i]. **Properties** * script : `String` * function name : `String` **Inputs** * IN\[0] : `Any` **Outputs** * function : `Function` **Utils** Calculate the average of a list of numbers **Inputs** * input values for average : `Number` **Outputs** * average of input values : `Number` Linear interpolation between two values: a \* (1 - t) + b \* t **Properties** * t : `Number` **Inputs** * a : `Number, Point, Vector` * b : `Number, Point, Vector` * t : `Number, Bool` **Outputs** * result : `Number, Point, Vector` Get the maximum of two numbers **Inputs** * first item for comparison : `Number` * second item for comparison : `Number` **Outputs** * maximum of first and second item : `Number` Get the minimum of two numbers **Inputs** * first item for comparison : `Number` * second item for comparison : `Number` **Outputs** * minimum of first and second item : `Number` Constant PI **Properties** * factor : `Number` **Inputs** * factor : `Number` **Outputs** * PI multiplied by factor : `Number` Generate random points inside a circle on a plane **Properties** * origin : `Point3d` * radius : `Number` * count : `Number` * seed : `Number` **Inputs** * plane : `Plane` * radius : `Number` * count : `Number` * seed : `Number` **Outputs** * points : `Point` ## Intersects **Math** Create contours from a mesh along a direction **Inputs** * shape : `Mesh` * start point of contour : `Point, Plane` * normal direction of contour : `Vector, Plane` * distance between contours : `Number` **Outputs** * contour : `Curve` Solve the intersection between two line curves **Inputs** * first line curve : `Curve` * second line curve : `Curve` **Outputs** * parameter on first line curve : `Number` * parameter on second line curve : `Number` * point on first line curve : `Point` * point on second line curve : `Point` Solve the intersection between a line curve and a plane **Inputs** * line curve : `Curve` * plane : `Plane` **Outputs** * intersection point : `Point` * parameter on line : `Number` * uv on plane : `Point` Solve the intersection between a mesh and a plane, return section curves **Inputs** * mesh : `Mesh` * section plane : `Plane` **Outputs** * section curves : `Curve` Solve the intersection between two planes, returns a line if they intersect **Inputs** * first plane : `Plane` * second plane : `Plane` **Outputs** * intersection line : `Curve` **Physical** Find the intersection between two curves by numerical methods **Inputs** * first curve : `Curve` * second curve : `Curve` **Outputs** * intersection points : `Point` * parameters on first curve : `Number` * parameters on second curve : `Number` **Shape** Boolean difference of meshes **Inputs** * first mesh : `Mesh` * second mesh set : `Mesh` **Outputs** * difference result : `Mesh` Boolean intersection of meshes **Inputs** * first mesh : `Mesh` * second mesh set : `Mesh` **Outputs** * intersection result : `Mesh` Boolean union of meshes **Inputs** * meshes to union : `Mesh` **Outputs** * union result : `Mesh` Boolean difference of a set of planar closed curves **Inputs** * first curve : `Curve` * second curve set : `Curve` **Outputs** * difference result : `Curve` Boolean intersection of a set of planar closed curves **Inputs** * first curve : `Curve` * second curve set : `Curve` **Outputs** * intersection result : `Curve` Boolean union of a set of planar closed curves **Inputs** * curves to union : `Curve` **Outputs** * union result : `Curve` ## Vector **Point** Construct a point in 3D space **Properties** * x : `Number` * y : `Number` * z : `Number` * point : `Point3d` **Inputs** * x : `Number` * y : `Number` * z : `Number` **Outputs** * point : `Point` Deconstruct a point into its components **Inputs** * point to deconstruct : `Point` **Outputs** * x component of a point : `Number` * y component of a point : `Number` * z component of a point : `Number` Calculate the distance between two points **Inputs** * first point : `Point` * second point : `Point` **Outputs** * distance between two points : `Number` Create a point from cylindrical coordinates **Properties** * base : `Point3d` * angle : `Number` * radius : `Number` * elevation : `Number` **Inputs** * base plane : `Plane` * angle : `Number` * radius : `Number` * elevation : `Number` **Outputs** * point : `Point` Project a point onto a curve **Inputs** * point to project : `Point` * projection direction : `Vector` * curve to project onto : `Curve` **Outputs** * projected point : `Point` **Vector** Set the amplitude of a vector **Properties** * factor : `Number` **Inputs** * base vector : `Vector, Plane` * amplitude factor : `Number` **Outputs** * resulting vector : `Vector` Calculate the angle between two vectors **Inputs** * first vector : `Vector, Plane, Curve` * second vector : `Vector, Plane, Curve` * optional plane for 2D angle : `Plane` **Outputs** * angle in radians between two vectors : `Number` Construct a vector in 3D space **Properties** * x : `Number` * y : `Number` * z : `Number` * vector : `Vector3d` **Inputs** * x : `Number` * y : `Number` * z : `Number` **Outputs** * vector with components : `Vector` * vector length : `Number` Calculate the cross product of two vectors **Inputs** * first vector : `Vector, Plane, Curve` * second vector : `Vector, Plane, Curve` **Outputs** * cross product of input vectors : `Vector` Deconstruct a vector into its components **Inputs** * vector to deconstruct : `Point, Vector, Plane` **Outputs** * x component of a vector : `Number` * y component of a vector : `Number` * z component of a vector : `Number` Rotate a vector around an axis **Properties** * axis : `Vector3d` * angle in degree : `Number` **Inputs** * vector to rotate : `Vector, Plane, Curve` * rotation axis : `Vector, Plane, Curve` * rotation angle in radians : `Number` **Outputs** * rotated vector : `Vector` Create a unit vector along the x-axis **Properties** * factor : `Number` **Inputs** * factor : `Number` **Outputs** * vector along x-axis multiplied by factor : `Vector` Create a unit vector along the y-axis **Properties** * factor : `Number` **Inputs** * factor : `Number` **Outputs** * vector along y-axis multiplied by factor : `Vector` Create a unit vector along the z-axis **Properties** * factor : `Number` **Inputs** * factor : `Number` **Outputs** * vector along z-axis multiplied by factor : `Vector` Create a vector from two points **Properties** * normalize : `Bool` **Inputs** * base point : `Point` * tip point : `Point` * normalize vector : `Bool` **Outputs** * resulting vector : `Vector` * vector length : `Number` Measure the length of a vector **Inputs** * vector to measure : `Vector, Curve` **Outputs** * vector length : `Number` **Plane** Construct a plane from origin, x axis and y axis **Properties** * origin : `Point3d` * x axis : `Vector3d` * y axis : `Vector3d` **Inputs** * origin of plane : `Point, Vector` * x axis direction of plane : `Vector` * y axis direction of plane : `Vector` **Outputs** * plane : `Plane` Deconstruct a plane into origin, x axis, y axis and normal **Inputs** * plane to deconstruct : `Plane` **Outputs** * origin point of plane : `Point` * x axis of plane : `Vector` * y axis of plane : `Vector` * normal of plane : `Vector` Flip a plane by reversing or swapping its axes **Properties** * reverse x axis : `Bool` * reverse y axis : `Bool` * swap x and y axis : `Bool` **Inputs** * plane to adjust : `Plane` * reverse the x-axis direction : `Bool` * reverse the y-axis direction : `Bool` * swap the x and y axis directions : `Bool` **Outputs** * flipped plane : `Plane` Construct a plane from 3 points **Inputs** * origin point : `Point` * x direction point : `Point` * orientation point : `Point` **Outputs** * plane : `Plane` Find the closest point on a plane to a given sample point **Inputs** * sample point : `Point` * plane : `Plane` **Outputs** * closest point on plane : `Point` * uv coordinate on plane : `Vector` * distance from sample point to plane : `Number` Construct a plane from origin and normal direction **Properties** * origin : `Point3d` * normal : `Vector3d` **Inputs** * origin : `Point, Vector` * normal : `Vector` **Outputs** * plane : `Plane` Construct a plane in XY plane **Properties** * origin : `Point3d` **Inputs** * origin of plane : `Point, Vector` **Outputs** * plane : `Plane` Construct a plane in XZ plane **Properties** * origin : `Point3d` **Inputs** * origin of plane : `Point, Vector` **Outputs** * plane : `Plane` Construct a plane in YZ plane **Properties** * origin : `Point3d` **Inputs** * origin of plane : `Point, Vector` **Outputs** * plane : `Plane` **Grid** Generate points using Poisson-disk sampling within a region **Properties** * min radius : `Number` * seed : `Number` * relax iterations : `Number` * sampling mode : `Category` **Inputs** * sampling region : `Curve, Mesh, Box` * min radius : `Number` * variable radius function f(x,y,z) -> scalar (mesh only) : `Function` * random seed : `Number` * relax iterations (surface mesh only) : `Number` **Outputs** * generated points : `Point` Generate a rectangular grid of curves & points **Properties** * origin : `Point3d` * sx : `Number` * sy : `Number` * ex : `Number` * ey : `Number` **Inputs** * origin of plane : `Point, Plane` * size grid cells in x direction : `Number` * size grid cells in y direction : `Number` * number of grid cells in x direction : `Number` * number of grid cells in y direction : `Number` **Outputs** * grid cell outline curves (list of curves in row-major order) : `Curve` * points at grid vertices (list of points in row-major order) : `Point` Generate a square grid of curves & points **Properties** * origin : `Point3d` * size : `Number` * ex : `Number` * ey : `Number` **Inputs** * origin of plane : `Point, Plane` * size of grid cells : `Number` * number of grid cells in x direction : `Number` * number of grid cells in y direction : `Number` **Outputs** * grid cell outline curves (list of curves in row-major order) : `Curve` * points at grid vertices (list of points in row-major order) : `Point` ## Curve **Primitive** Create an arc from a base plane, radius, and angles **Properties** * base : `Point3d` * radius : `Number` * start angle : `Number` * end angle : `Number` **Inputs** * base plane : `Point, Plane` * radius : `Number` * start angle : `Number` * end angle : `Number` **Outputs** * arc curve : `Curve` Create an arc from three points **Properties** * start : `Point3d` * middle : `Point3d` * end : `Point3d` **Inputs** * start point of arc : `Point, Plane` * middle point of arc : `Point, Plane` * end point of arc : `Point, Plane` **Outputs** * resulting arc : `Curve` * arc plane : `Plane` * arc radius : `Number` Create an arc from start point, end point, and direction at start **Properties** * start : `Point3d` * end : `Point3d` * direction : `Vector3d` **Inputs** * start point of arc : `Point, Plane` * end point of arc : `Point, Plane` * direction at start : `Vector, Plane` **Outputs** * resulting arc : `Curve` * arc plane : `Plane` * arc radius : `Number` Create a circle from a base plane and radius **Properties** * base : `Point3d` * radius : `Number` **Inputs** * base plane : `Point, Plane` * radius : `Number` **Outputs** * circle curve : `Curve` Create a circle from three points **Inputs** * first point on circle : `Point, Vector, Plane` * second point on circle : `Point, Vector, Plane` * third point on circle : `Point, Vector, Plane` **Outputs** * resulting circle curve : `Curve` * circle plane : `Plane` * circle radius : `Number` Create a line from a start point and end point **Properties** * start : `Point3d` * end : `Point3d` **Inputs** * start point of line curve : `Point, Vector, Plane` * end point of line curve : `Point, Vector, Plane` **Outputs** * line curve : `Curve` Create a line from a start point, direction, and length **Properties** * direction : `Vector3d` * length : `Number` **Inputs** * start point of line curve : `Point, Vector, Plane` * line direction : `Vector, Plane` * line length : `Number` **Outputs** * resulting line curve : `Curve` Create a regular polygon from a base plane, radius, number of segments, and fillet radius **Properties** * base : `Point3d` * radius : `Number` * segments : `Number` * fillet radius : `Number` **Inputs** * base plane : `Point, Plane` * radius : `Number` * segments : `Number` * fillet radius : `Number` **Outputs** * polygon curve : `Curve` * curve length : `Number` Create a rectangle from a base plane, x domain, and y domain **Properties** * origin : `Point3d` * x domain : `Vector2d` * y domain : `Vector2d` **Inputs** * base plane : `Point, Plane` * x domain : `Number, Domain` * y domain : `Number, Domain` **Outputs** * rectangle curve : `Curve` **Spline** Create a NURBS curve by interpolating points **Properties** * degree : `Number` * periodic : `Bool` * knot : `Category` **Inputs** * interpolating points : `Point` * curve degree : `Number` * periodic curve : `Bool` * knot style (0: uniform, 1: chordal, 2: centripetal) : `Number` **Outputs** * resulting curve : `Curve` * curve length : `Number` * curve domain : `Domain` Create iso curves from a surface **Properties** * uv : `Vector2d` **Inputs** * base surface : `Surface` * uv : `Point, Vector` **Outputs** * U iso curves : `Curve` * V iso curves : `Curve` Create a NURBS curve from control points & degree & periodicity **Properties** * degree : `Number` * periodic : `Bool` **Inputs** * control points : `Point` * curve degree : `Number` * periodic curve : `Bool` **Outputs** * resulting curve : `Curve` * curve length : `Number` * curve domain : `Domain` Create a polyline from a list of points **Properties** * closed : `Bool` **Inputs** * vertex points : `Point` * close polyline : `Bool` **Outputs** * resulting polyline : `Curve` **Analysis** Check if the input curve is closed **Inputs** * curve to check : `Curve` **Outputs** * true if closed : `Bool` Find the closest point on the curve to the input point **Inputs** * point to project curve : `Point` * input curve : `Curve` **Outputs** * point on the curve closest to input point : `Point` * parameter on the curve domain of closest point : `Number` * distance between input point and closest point : `Number` Extract NURBS control points and knots from a curve **Inputs** * curve to analyze : `Curve` **Outputs** * control points : `Point` * weights : `Number` * knots : `Number` * degree : `Number` Measure or modify the domain of a curve **Inputs** * curve to measure / modify : `Curve` * optional domain : `Number, Domain` **Outputs** * curve with new domain : `Curve` * domain of original curve : `Domain` Measure the length of the input curve **Inputs** * curve to measure : `Curve` **Outputs** * curve length : `Number` Find the end points of the curve **Inputs** * curve to evaluate : `Curve` **Outputs** * curve start point : `Point` * curve end point : `Point` Evaluate a curve at a parameter **Properties** * parameter : `Number` **Inputs** * curve to evaluate : `Curve` * parameter on curve domain to evaluate : `Number` **Outputs** * point on the curve at the parameter : `Point` * tanget vector on the curve at the parameter : `Vector` Evaluate a curve at a parameter on the normalized curve domain (0.0 \~ 1.0) **Properties** * parameter : `Range` **Inputs** * curve to evaluate : `Curve` * parameter on normalized curve domain (0.0 \~ 1.0) : `Number` **Outputs** * point on the curve at the normalized parameter : `Point` **Division** Divide a curve into segments **Properties** * segments : `Number` **Inputs** * curve to divide : `Curve` * segments : `Number` **Outputs** * points : `Point` * tangents : `Vector` * parameters : `Number` Shatter a curve at multiple parameters **Inputs** * curve to trim : `Curve` * parameter to split at : `Number` **Outputs** * shatterred remains : `Curve` **Utils** Convert a curve to a polyline with a given normal tolerance **Properties** * tolerance : `Number` **Inputs** * curve to convert : `Curve` * normal tolerance : `Number` **Outputs** * polyline curve : `Curve` * number of polyline segments : `Number` Explode a curve into its segments **Inputs** * curve to explode : `Curve` **Outputs** * exploded segments : `Curve` * verticies of the exploded segments : `Point` Fillet the sharp corners of the input curve **Properties** * radius : `Number` **Inputs** * curve to fillet : `Curve` * fillet radius : `Number` **Outputs** * fillet curve : `Curve` Fillet the sharp corner of the input curve at the given parameter **Properties** * parameter : `Number` * radius : `Number` **Inputs** * curve to fillet : `Curve` * parameters to fillet at : `Number` * fillet radii (single value or list with same length as parameters) : `Number` **Outputs** * fillet curve : `Curve` Flip the input curve **Inputs** * curve to flip : `Curve` **Outputs** * flipped curve : `Curve` Inflate a curve **Properties** * distance : `Number` * cap : `Category` * join : `Category` * side : `Category` **Inputs** * polyline curve to inflate : `Curve` * inflation distance : `Number` * plane for inflation (optional) : `Plane` * cap type (1: butt, 2: square) : `Number` * join type (1: bevel, 2: miter) : `Number` * side type (1: inner, 2: outer, 3: both) : `Number` **Outputs** * inflated curves : `Curve` Join the input curves **Properties** * threshold : `Number` **Inputs** * curves to join : `Curve` **Outputs** * joined curves : `Curve` Offset a curve **Properties** * distance : `Number` * corner : `Category` **Inputs** * curve to offset : `Curve` * offset distance : `Number` * plane for offset (optional) : `Plane` * corner type (1: sharp, 2: round, 3: smooth, 4: chamfer) : `Number` **Outputs** * offset curve : `Curve` Reparameterize a curve **Inputs** * curve to reparameterize : `Curve` **Outputs** * reparameterized curve : `Curve` Create a text curve **Properties** * text : `String` * scale : `Number` * margin : `Number` **Inputs** * text : `String` * text scale : `Number` * margin between characters : `Number` **Outputs** * text curves : `Curve` ## Surface **Primitive** Create a bounding box from a geometry **Properties** * union : `Bool` **Inputs** * geometry to contain : `Point, Curve, Surface, Brep, Mesh, Box, Implicit, Field` * bounding box orientation plane : `Point, Plane` **Outputs** * aligned bounding box in world coordinates : `Box` Create a box centered at a given point **Properties** * origin : `Point3d` * size x : `Number` * size y : `Number` * size z : `Number` **Inputs** * base plane : `Point, Plane` * size in x direction : `Number, Domain` * size in y direction : `Number, Domain` * size in z direction : `Number, Domain` **Outputs** * box : `Box` Create a box from a domain **Properties** * origin : `Point3d` * domain x : `Vector2d` * domain y : `Vector2d` * domain z : `Vector2d` **Inputs** * base plane : `Point, Plane` * domain in x direction : `Number, Domain` * domain in y direction : `Number, Domain` * domain in z direction : `Number, Domain` **Outputs** * box : `Box` Create a plane surface from a plane and dimensions **Properties** * base : `Point3d` * x : `Vector2d` * y : `Vector2d` **Inputs** * surface base plane : `Point, Plane` * dimensions in x direction : `Number, Domain` * dimensions in y direction : `Number, Domain` **Outputs** * resulting plane surface : `Surface` Create a sphere surface from a base plane and radius **Properties** * base : `Point3d` * radius : `Number` **Inputs** * surface base plane : `Point, Plane` * sphere radius : `Number` **Outputs** * resulting sphere surface : `Surface` Create a torus surface from a plane, major/minor radii, and domains **Properties** * base : `Point3d` * major\_radius : `Number` * minor\_radius : `Number` * u\_domain : `Vector2d` * v\_domain : `Vector2d` **Inputs** * surface base plane : `Point, Plane` * major radius : `Number` * minor radius : `Number` * u domain : `Domain` * v domain : `Domain` **Outputs** * resulting torus surface : `Surface` Create a triangle surface from three points **Properties** * a : `Point3d` * b : `Point3d` * c : `Point3d` **Inputs** * point a : `Point` * point b : `Point` * point c : `Point` **Outputs** * resulting triangle surface : `Surface` **Freeform** Create boundary surfaces from a list of boundary curves **Inputs** * boundary curves : `Curve` **Outputs** * boundary surfaces : `Surface` Extrude a profile curve or surface **Inputs** * profile surface or curve : `Curve, Surface, Implicit` * extrusion direction : `Vector` **Outputs** * extrusion result : `Surface, Brep, Implicit` Extrude a profile curve or surface to a point **Inputs** * profile surface or curve : `Curve, Surface` * extrusion tip : `Point, Vector` **Outputs** * extrusion result : `Surface, Brep` Loft a list of section curves into a surface **Properties** * section degree : `Number` **Inputs** * section curves : `Curve` * section degree : `Number` **Outputs** * resulting lofted surface : `Surface` Create a pipe from a base curve **Properties** * radius : `Number` * cap : `Category` **Inputs** * base curve : `Curve` * pipe radius : `Number` **Outputs** * resulting pipe : `Surface, Brep` Loft a list of section curves into a surface **Properties** * angle domain : `Vector2d` **Inputs** * profile curve : `Curve` * revolution axis : `Vector` * angle domain : `Number, Domain` **Outputs** * resulting surface : `Surface` Create a NURBS surface from a grid of points **Properties** * u count : `Number` * u degree : `Number` * v degree : `Number` * interpolate : `Bool` **Inputs** * points : `Point` * u count : `Number` * u degree : `Number` * v degree : `Number` * interpolate : `Bool` **Outputs** * surface : `Surface` Sweep a profile curve along a path curve **Properties** * degree : `Number` **Inputs** * profile curve : `Curve` * rail curve : `Curve` * degree : `Number` **Outputs** * resulting surface : `Surface` **Analysis** Compute the area of a geometry **Inputs** * geometry for area computation : `Curve, Surface, Brep, Mesh, Box` **Outputs** * area of geometry : `Number` * area centroid of geometry : `Point` Get the properties of a Box **Inputs** * box to get properties from : `Box` **Outputs** * center of box : `Point` * min of box : `Point` * max of box : `Point` * area of box : `Number` * volume of box : `Number` Deconstruct a BBox into its components **Inputs** * box to deconstruct : `Box` **Outputs** * plane of box : `Plane` * x domain of box : `Domain` * y domain of box : `Domain` * z domain of box : `Domain` Deconstruct a Brep into its faces, edges, and vertices **Inputs** * brep to deconstruct : `Surface, Brep, Box` **Outputs** * faces of brep : `Surface` * edges of brep : `Curve` * vertices of brep : `Point` Evaluate a surface at a given UV coordinate **Properties** * uv : `Vector2d` **Inputs** * surface to evaluate : `Plane, Surface` * uv coordinate to evaluate : `Vector` **Outputs** * point at uv : `Point` * normal vector at uv : `Vector` * frame at uv : `Plane` Find the closest point on a surface to a given point **Inputs** * sample point : `Point` * surface to search : `Surface` **Outputs** * closest point : `Point` * uv coordinate of closest point : `Vector` * distance between sample point and surface : `Number` Extract NURBS properties from a surface **Inputs** * surface to analyze : `Surface` **Outputs** * control points : `Point` * weights : `Number` * u knots : `Number` * v knots : `Number` * u count : `Number` * v count : `Number` * u degree : `Number` * v degree : `Number` Measure the domain of a surface **Inputs** * surface to measure : `Surface` **Outputs** * u domain of surface : `Domain` * v domain of surface : `Domain` Compute the volume and centroid of a closed Brep or Mesh **Inputs** * geometry for volume computation : `Brep, Mesh, Box` **Outputs** * volume of geometry : `Number` * volume centroid of geometry : `Point` **Utils** Select faces, edges, or vertices from a brep interactively **Properties** * mode : `Category` * indices : `NumberVector` **Inputs** * brep : `Surface, Brep` **Outputs** * selected : `Point, Curve, Surface` Cap holes in a surface **Inputs** * geometry to cap holes : `Surface` **Outputs** * capped geometry : `Brep` Divide a surface into segments **Properties** * u segments : `Number` * v segments : `Number` **Inputs** * surface to divide : `Surface` * number of segments in u direction : `Number` * number of segments in v direction : `Number` **Outputs** * division points : `Point` * normal vectors at division points : `Vector` * parameter coordinates at division points : `Vector` Flip a surface to invert its normal **Properties** * direction : `Category` **Inputs** * surface to flip : `Surface` * flip direction (0 = U, 1 = V, 2 = UV) : `Number` **Outputs** * flipped surface : `Surface` Extract a sub-surface from a surface using a UV domain **Properties** * u\_domain : `Vector2d` * v\_domain : `Vector2d` **Inputs** * base surface : `Surface` * u domain : `Number, Domain` * v domain : `Number, Domain` **Outputs** * sub-surface : `Surface` Swap the U and V parameter directions of a surface **Inputs** * surface to swap : `Surface` **Outputs** * swapped surface : `Surface` ## Mesh **Primitive** Construct a face from indices of three vertices **Inputs** * index of first vertex : `Number` * index of second vertex : `Number` * index of third vertex : `Number` **Outputs** * face : `MeshFace` Construct a mesh from a list of vertices and faces **Inputs** * vertices of a mesh : `Point` * faces of a mesh : `MeshFace` * normals of a mesh : `Vector` **Outputs** * mesh : `Mesh` Create a box mesh **Properties** * center : `Point3d` * size : `Vector3d` * x faces : `Number` * y faces : `Number` * z faces : `Number` **Inputs** * base box : `Box` * face count in x direction : `Number` * face count in y direction : `Number` * face count in z direction : `Number` **Outputs** * mesh box : `Mesh` Create an icosphere mesh **Properties** * base : `Point3d` * radius : `Number` * subdivisions : `Number` **Inputs** * base : `Point, Plane` * radius : `Number` * subdivisions : `Number` **Outputs** * mesh icosphere : `Mesh` Create a plane mesh **Properties** * x boundary : `Vector2d` * y boundary : `Vector2d` * x faces : `Number` * y faces : `Number` **Inputs** * base boundary : `Domain, Curve` * face count in x direction : `Number` * face count in y direction : `Number` **Outputs** * mesh : `Mesh` **Analysis** Deconstruct a face into its three vertices **Inputs** * face to deconstruct : `MeshFace` **Outputs** * index of first vertex : `Number` * index of second vertex : `Number` * index of third vertex : `Number` Deconstruct a mesh into its vertices, faces, and normals **Inputs** * mesh to deconstruct : `Mesh` **Outputs** * vertices of mesh : `Point` * faces of mesh : `MeshFace` * normals of mesh : `Vector` Extract face normals **Inputs** * mesh for extraction : `Mesh` **Outputs** * center points for faces : `Point` * normals for faces : `Vector` Check if a mesh is 2-manifold **Inputs** * mesh to check manifoldness : `Mesh` **Outputs** * is manifold : `Bool` Approximate per-vertex curvature on a mesh. When `integrated` is true, returns the curvature integrated over the local vertex area (angle defect in radians for Gaussian) **Properties** * variant : `Category` * integrated : `Bool` **Inputs** * mesh to analyze : `Mesh` * variant : `Number` * integrated : `Bool` **Outputs** * curvature per vertex : `Number` Extract edges from a mesh and categorize by valence (number of adjacent faces) **Inputs** * mesh to extract edges from : `Mesh` **Outputs** * edges with a single adjacent face : `Curve` * edges with two adjacent faces : `Curve` * edges with more than two adjacent faces : `Curve` **Triangulation** Create a 2D convex hull polyline curve from points projected onto a plane **Properties** * normal : `Vector3d` **Inputs** * points to project : `Point` * projection plane : `Vector, Plane` **Outputs** * convex hull polyline : `Curve` Create a 3D convex hull mesh from a list of 3D points **Inputs** * points for convex hull : `Point` **Outputs** * convex hull mesh : `Mesh` Generate Voronoi diagram from points projected onto a plane **Inputs** * points to generate voronoi cells : `Point` * boundary for voronoi diagram : `Curve` * projection plane (optional) : `Vector, Plane` **Outputs** * voronoi cell boundaries (polylines) : `Curve` Generate a 3D Voronoi tessellation from seed points **Properties** * padding : `Number` **Inputs** * seed points : `Point` * boundary (optional) : `Brep, Mesh, Box` * padding : `Number` **Outputs** * mesh : `Mesh` * edges : `Curve` * cell centroids : `Point` **Utils** Flip a mesh **Inputs** * mesh to flip : `Mesh` **Outputs** * flipped mesh : `Mesh` Join meshes into a single mesh **Inputs** * meshes to join : `Mesh` **Outputs** * joined mesh : `Mesh` Create a mesh from a brep or surface **Inputs** * brep to meshing : `Surface, Brep` * meshing quality settings : `Quality` **Outputs** * mesh : `Mesh` Compute the dual cell outlines of a mesh: one closed polyline per input vertex through the centroids of its surrounding faces. **Properties** * unique edges : `Bool` **Inputs** * mesh : `Mesh` * output unique edges (no duplicated segments) : `Bool` **Outputs** * dual curves : `Curve` Create mesh tessellation quality settings **Properties** * chord height tolerance : `Number` * normal tolerance : `Number` * min edge length : `Number` * max edge length : `Number` **Inputs** * chord height tolerance : `Number` * normal tolerance : `Number` * min edge length : `Number` * max edge length : `Number` **Outputs** * quality settings : `Quality` Split a mesh into two parts using a plane **Inputs** * mesh : `Mesh` * split plane : `Plane` **Outputs** * positive side mesh : `Mesh` * negative side mesh : `Mesh` Create a mesh from a surface **Properties** * u divisions : `Number` * v divisions : `Number` **Inputs** * surface to meshing : `Surface` * number of divisions in u direction : `Number` * number of divisions in v direction : `Number` **Outputs** * uv mesh : `Mesh` Attach a per-vertex color list to a mesh **Inputs** * mesh to color : `Mesh` * colors per vertex : `Color` **Outputs** * colored mesh : `Mesh` Reduce mesh triangle count while preserving shape **Properties** * target ratio : `Range` **Inputs** * mesh to reduce : `Mesh` * target ratio (0: max reduction, 1: no reduction) : `Number` **Outputs** * reduced mesh : `Mesh` Smooth a mesh using mean curvature flow **Properties** * iterations : `Number` * lambda : `Number` **Inputs** * mesh : `Mesh` * iterations : `Number` * lambda : `Number` **Outputs** * smoothed mesh : `Mesh` Unweld vertices of a mesh **Inputs** * mesh to unweld : `Mesh` **Outputs** * unwelded mesh : `Mesh` Weld vertices of a mesh **Properties** * threshold : `Number` **Inputs** * mesh to weld : `Mesh` * distance threshold between vertices : `Number` **Outputs** * welded mesh : `Mesh` Add height-map bumps to a mesh's surface. **Properties** * projection : `Category` * sharpness : `Number` **Inputs** * mesh : `Mesh` * height map config : `Config` * sharpness (triplanar) or plane (planar) : `Number, Point, Plane` **Outputs** * displaced mesh : `Mesh` ## Volume **Analysis** Deconstruct a VolumeMesh into individual cell meshes **Inputs** * volume mesh : `VolumeMesh` **Outputs** * cell meshes : `Mesh` **Utils** Convert a surface mesh to a volume mesh **Properties** * edge length : `Number` * tolerance : `Number` **Inputs** * mesh : `Mesh` * edge length : `Number` * tolerance : `Number` **Outputs** * volume mesh : `VolumeMesh` ## Implicit **Primitive** Create a distance field from a quadratic Bezier curve **Properties** * p0 : `Point3d` * p1 : `Point3d` * p2 : `Point3d` **Inputs** * start point : `Point, Vector` * control point : `Point, Vector` * end point : `Point, Vector` **Outputs** * bezier curve implicit : `Implicit` Create a box Implicit primitive **Properties** * center : `Point3d` * size : `Vector3d` **Inputs** * size or box : `Vector, Box` **Outputs** * box implicit : `Implicit` Create a cylinder Implicit primitive **Properties** * base : `Point3d` * radius : `Number` * height : `Number` **Inputs** * base : `Point, Vector, Plane` * radius : `Number` * height : `Number` **Outputs** * cylinder implicit : `Implicit` Create an infinite plane Implicit primitive **Properties** * normal : `Vector3d` * constant : `Number` **Inputs** * base plane : `Point, Vector, Plane` **Outputs** * plane implicit : `Implicit` Create a sphere Implicit primitive **Properties** * base : `Point3d` * radius : `Number` **Inputs** * center : `Point, Vector, Plane` * radius : `Number` **Outputs** * sphere implicit : `Implicit` Create a torus Implicit primitive **Properties** * base : `Point3d` * major radius : `Number` * minor radius : `Number` **Inputs** * center : `Point, Vector, Plane` * major radius : `Number` * minor radius : `Number` **Outputs** * torus implicit : `Implicit` **Boolean** Subtract one Implicit field from another **Properties** * smooth radius : `Number` **Inputs** * base : `Implicit` * subtract : `Implicit` * smooth radius : `Number` **Outputs** * result : `Implicit` Combine Implicit fields using intersection (max) operation **Properties** * smooth radius : `Number` **Inputs** * shape A : `Implicit` * shape B : `Implicit` * smooth radius : `Number` **Outputs** * intersection : `Implicit` Combine Implicit fields using union (min) operation **Properties** * smooth radius : `Number` **Inputs** * shapes : `Implicit` * smooth radius : `Number` **Outputs** * combined : `Implicit` **Modifier** Extrude an Implicit shape along a direction. The vector length determines the extrusion length. **Properties** * direction : `Vector3d` **Inputs** * profile implicit : `Implicit` * extrusion direction : `Vector` **Outputs** * extruded implicit : `Implicit` Invert the Implicit field (negate distance, inside becomes outside) **Inputs** * input shape : `Implicit` **Outputs** * inverted : `Implicit` Expand or contract the Implicit surface by a distance **Properties** * distance : `Number` **Inputs** * input shape : `Implicit` * distance : `Number` **Outputs** * offset implicit : `Implicit` Create a hollow shell around the Implicit surface **Properties** * thickness : `Number` * direction : `Category` **Inputs** * input shape : `Implicit` * thickness : `Number` * direction (0: Inward, 1: Outward, 2: Center) : `Number` **Outputs** * shell implicit : `Implicit` Thicken a surface into a solid by adding thickness around the zero-isosurface **Properties** * thickness : `Number` **Inputs** * input shape : `Implicit` * thickness : `Number` **Outputs** * thickened implicit : `Implicit` **Lattice** Create a cylindrical cell map that wraps around a central axis **Properties** * unit radius : `Number` * unit height : `Number` * arc count : `Number` * linear : `Bool` **Inputs** * boundary : `Curve, Surface, Brep, Mesh, Box, Implicit` * unit radius : `Number` * unit height : `Number` * arc count : `Number` * frame : `Plane` * linear : `Bool` **Outputs** * cell map : `CellMap` Create a dual surface cell map that maps TPMS/lattice patterns between two surfaces **Properties** * count : `Vector3d` **Inputs** * surface a : `Surface, Brep` * surface b : `Surface, Brep` * count (u, v, w) : `Vector` **Outputs** * cell map : `CellMap` Tile a beam lattice across a cell map **Properties** * type : `Category` * unit size : `Vector3d` * beam radius : `Number` **Inputs** * lattice type : `Number` * unit cell size or map : `Number, Point, Vector, CellMap` * beam radius (number or implicit) : `Number, Implicit` **Outputs** * beam lattice : `Implicit` Remap a driving scalar (plane/point distance, or a field value such as stress) from the input range \[in min, in max] onto the output range \[out min, out max], shaped by a curve. Drives variable beam radius / TPMS thickness. **Properties** * in min : `Number` * in max : `Number` * out min : `Number` * out max : `Number` * curve : `Category` **Inputs** * reference: driving scalar (plane/point distance, or field value) : `Point, Plane, Implicit, Field` * in min (driving value mapped to out min) : `Number` * in max (driving value mapped to out max) : `Number` * out min (output at in min) : `Number` * out max (output at in max) : `Number` **Outputs** * ramp field (remapped scalar implicit) : `Implicit` Tile a Triply Periodic Minimal Surface (TPMS) across a cell map **Properties** * type : `Category` * unit size : `Vector3d` * iso value : `Number` * thickness : `Number` **Inputs** * tpms type (0: Gyroid, 1: SchwarzP, 2: SchwarzD, 3: Diamond, 4: Neovius, 5: Lidinoid) : `Number` * unit cell size or map : `Number, Point, Vector, CellMap` * iso value : `Number` * thickness (number or implicit field) : `Number, Implicit` **Outputs** * TPMS implicit : `Implicit` Tile a user-defined Implicit body across a cell map **Properties** * unit size : `Vector3d` * up : `Category` * yaw : `Category` **Inputs** * unit cell (implicit) : `Implicit` * unit cell size or map : `Number, Point, Vector, CellMap` * bounds (defaults to unit cell bbox) : `Curve, Surface, Brep, Mesh, Box, Implicit` * up axis (0:+Z 1:-Z 2:+X 3:-X 4:+Y 5:-Y) : `Number` * yaw (0:0° 1:90° 2:180° 3:270°) : `Number` **Outputs** * unit cell lattice : `Implicit` Create a beam lattice Implicit field from VolumeMesh **Properties** * lattice type : `Category` * beam radius : `Number` * include boundary : `Bool` **Inputs** * volume mesh : `VolumeMesh` * lattice type : `Number` * beam radius : `Number, Function` * include boundary : `Bool` **Outputs** * implicit : `Implicit` Create a Voronoi distance field from a point cloud **Properties** * padding : `Number` * distance\_mode : `Category` * thickness : `Number` **Inputs** * seed points : `Point` * padding : `Number` * thickness (number or implicit function f(x,y,z) -> scalar) : `Number, Implicit` **Outputs** * voronoi implicit : `Implicit` Create a rectangular cell map for TPMS/lattice coordinate transformation **Properties** * unit size : `Vector3d` **Inputs** * boundary : `Curve, Surface, Brep, Mesh, Box, Implicit` * unit cell size : `Number, Point, Vector` * frame (optional) : `Plane` **Outputs** * cell map : `CellMap` Create a spherical cell map that wraps around a central point **Properties** * unit radius : `Number` * latitude count : `Number` * longitude count : `Number` * linear : `Bool` **Inputs** * boundary : `Curve, Surface, Brep, Mesh, Box, Implicit` * unit radius : `Number` * latitude count : `Number` * longitude count : `Number` * frame : `Plane` * linear : `Bool` **Outputs** * cell map : `CellMap` Create a surface cell map that maps TPMS/lattice patterns onto a surface using UV coordinates **Properties** * count : `Vector3d` * height : `Number` * offset : `Number` * cell offset axis : `Category` * cell offset amount : `Number` **Inputs** * surface : `Surface, Brep` * count (u, v, w) : `Vector` * height (surface normal direction) : `Number` * offset (surface normal direction) : `Number` * cell offset axis (0: U per V-row, 1: V per U-col) : `Number` * cell offset amount (cells; 0 = none, 0.5 = brick) : `Number` **Outputs** * cell map : `CellMap` **Convert** Convert a list of line / polyline curves into a beam-lattice Implicit field via EdgeBeamsStructure (BVH-accelerated). **Properties** * beam radius : `Number` **Inputs** * line / polyline curves : `Curve` * beam radius (number or implicit) : `Number, Implicit` **Outputs** * beams implicit : `Implicit` Convert brep to an Implicit field **Properties** * length tolerance (mm) : `Number` **Inputs** * geometry to convert : `Curve, Surface, Brep, Mesh, Box` * length tolerance (mm) : `Number` **Outputs** * implicit : `Implicit` Convert a curve to an Implicit field **Properties** * length tolerance (mm) : `Number` **Inputs** * curve to convert : `Curve` * length tolerance (mm) : `Number` **Outputs** * curve implicit : `Implicit` Export Implicit field to mesh file **Properties** * file name : `String` * format : `Category` * tolerance : `Number` * sharpen : `Bool` * simplify target ratio : `Range` * iso level : `Number` **Inputs** * implicit : `Implicit` * file name : `String` * format (0: stl, 1: obj, 2: gltf, 3: glb, 4: ply, 5: json) : `Number` * bounds (optional) : `Box` * tolerance : `Number` * sharpen : `Bool` * simplify target ratio (0: max reduction, 1: no reduction) : `Number` * iso level : `Number` Convert a Field density field to an Implicit field for GPU operations **Properties** * threshold : `Range` **Inputs** * field to convert : `Field` * bounds : `Box` * threshold : `Number` **Outputs** * implicit : `Implicit` Convert an Implicit field to a mesh with tolerance-based resolution **Properties** * tolerance : `Number` * sharpen : `Bool` * simplify target ratio : `Range` * iso level : `Number` **Inputs** * implicit : `Implicit` * bounds (optional) : `Box` * tolerance : `Number` * sharpen : `Bool` * simplify target ratio (0: max reduction, 1: no reduction) : `Number` * iso level : `Number` **Outputs** * mesh : `Mesh` Convert a mesh to an Implicit field **Inputs** * mesh to convert : `Mesh` **Outputs** * implicit : `Implicit` Convert VolumeMesh with FEM attributes to Implicit field (tetra scalar field) **Properties** * attribute : `Category` **Inputs** * volume mesh to convert : `VolumeMesh` **Outputs** * tetra scalar field : `Implicit` * min scalar : `Number` * max scalar : `Number` **Script** Create a custom Implicit field using WGSL code. Use `p` for position (vec3f), `IN[i]` for scalar/vector params, and `IN[i](p)` for Implicit params. Must include return statement. **Properties** * expression : `String` **Inputs** * IN\[0] : `Any` **Outputs** * implicit : `Implicit` **HeightMap** Settings (image, amplitude, scale, offset) for height map nodes. **Properties** * amplitude : `Number` * uv scale : `Vector2d` * uv offset : `Vector2d` **Inputs** * texture (height map, red channel) : `Texture` * amplitude (world units) : `Number` * uv scale : `Vector` * uv offset : `Vector` **Outputs** * height map config : `Config` Add height-map bumps to an implicit shape's surface. **Properties** * projection : `Category` * sharpness : `Number` **Inputs** * input shape : `Implicit` * height map config : `Config` * sharpness (triplanar) or plane (planar) : `Number, Point, Plane` **Outputs** * height implicit : `Implicit` Lay a height-map relief over a surface as a solid body. **Properties** * thickness : `Number` * direction : `Category` **Inputs** * surface cell map : `CellMap` * height map config : `Config` * thickness : `Number` * direction (0: Inward, 1: Outward, 2: Center) : `Number` **Outputs** * surface relief implicit : `Implicit` ## Texture **Utils** Blur a texture to smooth it. **Properties** * sigma : `Range` * repeatable : `Bool` **Inputs** * texture : `Texture` * sigma (pixels) : `Number` * repeatable : `Bool` **Outputs** * texture : `Texture` Create a texture of a given size and color. **Properties** * width : `Number` * height : `Number` * color : `Color` **Inputs** * width : `Number` * height : `Number` * color : `Color` **Outputs** * texture : `Texture` Get a texture's width and height. **Inputs** * texture : `Texture` **Outputs** * width : `Number` * height : `Number` Flip a texture horizontally and/or vertically. **Properties** * flip u (horizontal) : `Bool` * flip v (vertical) : `Bool` **Inputs** * texture : `Texture` * flip u (horizontal) : `Bool` * flip v (vertical) : `Bool` **Outputs** * texture : `Texture` Invert a texture's colors. **Inputs** * texture : `Texture` **Outputs** * texture : `Texture` Generate a Perlin or Simplex noise texture. **Properties** * width : `Number` * height : `Number` * noise type : `Category` * scale : `Vector3d` * offset : `Vector3d` * octaves : `Number` * repeatable : `Bool` **Inputs** * width : `Number` * height : `Number` * noise type : `Number` * scale : `Number, Vector` * offset : `Number, Vector` * octaves : `Number` * repeatable : `Bool` **Outputs** * texture : `Texture` Convert a normal map into a height map. **Properties** * tileable : `Bool` * flatten : `Range` **Inputs** * normal map : `Texture` * tileable : `Bool` * flatten : `Number` **Outputs** * height map : `Texture` Rotate a texture in 90° steps. **Properties** * angle : `Number` **Inputs** * texture : `Texture` * angle (0=0°, 1=90°, 2=180°, 3=270°) : `Number` **Outputs** * texture : `Texture` Read the color at a point in a texture. **Properties** * x : `Number` * y : `Number` * sampling : `Category` **Inputs** * texture : `Texture` * x : `Number` * y : `Number` * sampling : `Number` **Outputs** * color : `Color` Adjust a texture's brightness and contrast. **Properties** * brightness : `Number` * contrast : `Number` **Inputs** * texture : `Texture` * brightness (-1 to 1) : `Number` * contrast (-1 to 1) : `Number` **Outputs** * texture : `Texture` Make a texture repeat seamlessly. **Properties** * blend : `Range` **Inputs** * texture : `Texture` * blend (0 to 1) : `Number` **Outputs** * texture : `Texture` ## Analysis **Material** Define isotropic material for Meshless analysis **Properties** * name : `String` * Young's modulus : `Number` * Poisson's ratio : `Range` * density : `Number` **Inputs** * name : `String` * Young's modulus : `Number` * Poisson's ratio : `Number` * density : `Number` **Outputs** * material : `Analysis` Define isotropic thermal material for Meshless thermal analysis **Properties** * name : `String` * conductivity : `Number` * density : `Number` * specific heat : `Number` **Inputs** * name : `String` * conductivity W/(m·K) : `Number` * density kg/m³ : `Number` * specific heat J/(kg·K) : `Number` **Outputs** * thermal material : `Analysis` **Boundary Condition** Convective heat transfer BC (q = h·(T - T∞)) for Meshless thermal analysis **Properties** * coefficient : `Number` * environment temperature : `Number` **Inputs** * boundary (mesh, point, or selection) : `Point, Mesh, Analysis` * coefficient W/(m²·K) : `Number` * environment temperature : `Number` **Outputs** * boundary condition : `Analysis` Fixed (Dirichlet) boundary condition with per-axis DOF control **Properties** * fix x : `Bool` * fix y : `Bool` * fix z : `Bool` **Inputs** * boundary (mesh, point, or selection) : `Point, Mesh, Analysis` * fix x : `Number, Bool` * fix y : `Number, Bool` * fix z : `Number, Bool` **Outputs** * boundary condition : `Analysis` Force (vector) boundary condition **Properties** * force : `Vector3d` **Inputs** * boundary (mesh, point, or selection) : `Point, Mesh, Analysis` * force : `Vector` **Outputs** * boundary condition : `Analysis` Heat flux boundary condition (W/m², positive = into body) for Meshless thermal analysis **Properties** * flux : `Number` **Inputs** * boundary (mesh, point, or selection) : `Point, Mesh, Analysis` * flux W/m² : `Number` **Outputs** * boundary condition : `Analysis` Prescribed temperature (Dirichlet) boundary condition **Properties** * temperature : `Number` **Inputs** * boundary (mesh, point, or selection) : `Point, Mesh, Analysis` * temperature : `Number` **Outputs** * boundary condition : `Analysis` **Meshless** Run implicit static stress analysis via Meshless analysis **Properties** * tolerance : `Number` * half bandwidth : `Number` * gpu solver : `Bool` * cache : `Bool` **Inputs** * implicit : `Implicit` * configurations : `Analysis` * bounds (optional) : `Box` **Outputs** * result : `Field` **Utils** Get the min/max domain of a named attribute from a VolumeMesh or VTU **Properties** * attribute name : `String` **Inputs** * input : `VolumeMesh, VTU` * attribute name : `String` **Outputs** * domain : `Domain` Get the list of available attribute names from a VolumeMesh or VTU **Inputs** * input : `VolumeMesh, VTU` **Outputs** * attribute names : `String` ## Transform **Affine** Project geometry onto a plane **Properties** * plane normal : `Vector3d` **Inputs** * base geometry : `Point, Vector, Curve, Surface, Brep, Mesh, Box` * plane : `Vector, Plane` **Outputs** * projected geometry : `Point, Curve, Surface, Brep, Mesh, Box` Project geometry onto a plane along a given direction **Properties** * plane normal : `Vector3d` * direction : `Vector3d` **Inputs** * base geometry : `Point, Curve, Surface, Brep, Mesh, Box` * plane : `Vector, Plane` * direction : `Vector` **Outputs** * projected geometry : `Point, Curve, Surface, Brep, Mesh, Box` Scale geometry by a given factor around a center point **Properties** * factor : `Number` **Inputs** * base geometry : `Point, Curve, Surface, Brep, Mesh, Box, Implicit` * center of scaling : `Point, Vector, Plane` * scaling factor : `Number` **Outputs** * scaled geometry : `Point, Curve, Surface, Brep, Mesh, Box, Implicit` Scale geometry by non-uniform factors along input plane axes **Properties** * x factor : `Number` * y factor : `Number` * z factor : `Number` **Inputs** * base geometry : `Point, Curve, Surface, Brep, Mesh, Box, Implicit` * base plane : `Point, Vector, Plane` * scaling factor in x direction : `Number` * scaling factor in y direction : `Number` * scaling factor in z direction : `Number` **Outputs** * scaled geometry : `Point, Curve, Surface, Brep, Mesh, Box, Implicit` **Euclidean** Mirror geometry along a plane **Inputs** * geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * mirror plane : `Plane` **Outputs** * mirrored geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` Move geometry by a given translation vector **Properties** * translation vector : `Vector3d` **Inputs** * geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * translation vector : `Point, Vector` **Outputs** * translated geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` Orient geometry from one plane to another **Inputs** * geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * initial plane : `Plane` * target plane : `Plane` **Outputs** * oriented geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * orientation transform : `Matrix` Rotate geometry around an axis **Properties** * angle : `Number` * center : `Point3d` * axis : `Vector3d` **Inputs** * geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * rotation angle in radians : `Number` * center of rotation : `Point` * axis of rotation : `Vector` **Outputs** * translated geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` Rotate geometry on a plane **Properties** * angle : `Number` **Inputs** * geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * rotation angle in radians : `Number` * base plane : `Point, Plane` **Outputs** * rotated geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` **Array** Create a linear array of geometry **Properties** * direction : `Vector3d` * count : `Number` **Inputs** * geometry : `Point, Curve, Surface, Brep, Mesh, Box, Implicit` * linear array direction : `Vector` * number of elements in array : `Number` **Outputs** * arrayed geometry : `Point, Curve, Surface, Brep, Mesh, Box, Implicit` Create a rectangular array of geometry **Properties** * x boundary : `Vector2d` * y boundary : `Vector2d` * x count : `Number` * y count : `Number` **Inputs** * geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` * rectangle : `Domain, Curve` * number of elements in x direction : `Number` * number of elements in y direction : `Number` **Outputs** * arrayed geometry : `Point, Plane, Curve, Surface, Brep, Mesh, Box, Implicit` **Morph** Map a geometry to a target surface space from its location relative to a source surface space **Inputs** * geometry to map : `Point, Curve, Mesh` * source surface : `Surface` * target surface : `Surface` **Outputs** * mapped geometry : `Point` **Utils** Group a list of geometries **Inputs** * objects to group : `Curve, Surface, Brep, Mesh, Box` **Outputs** * resulting group : `Group` Ungroup a group of geometries **Inputs** * group to ungroup : `Group` **Outputs** * objects in group : `Curve, Surface, Brep, Mesh, Box` ## Display **Vector** Preview point list in viewport **Properties** * size : `Number` **Inputs** * Point list to display : `Point, Plane` * Point size : `Number` Preview vectors in viewport **Inputs** * anchor point : `Point, Vector, Plane` * vector to display : `Vector, Plane` **Field** Visualize 3D field data with color mapping using Data3DTexture **Properties** * color map : `Category` * transparency : `Range` **Inputs** * field to display : `Field` * bounds : `Box` * transparency : `Number` **Implicit** Display an implicit shape coloured by a VolumeField **Properties** * color map : `Category` * auto range : `Bool` * min value : `Number` * max value : `Number` * transparency : `Range` **Inputs** * implicit (optional) : `Implicit` * field : `Field` * min value : `Number` * max value : `Number` * transparency : `Number` Visualize Implicit distance field slice as iso-contours in viewport **Properties** * resolution : `Vector2d` * slice position : `Range` * slice axis : `Category` * view mode : `Category` * flip direction : `Bool` * color mode : `Category` **Inputs** * implicit : `Implicit` * bounds (optional) : `Box, Implicit` * resolution : `Number, Vector` * slice position : `Number` * slice axis : `Number` * view mode (0=Both, 1=Heatmap, 2=Implicit) : `Number` * flip direction : `Number, Bool` **Texture** Display a texture image in the viewport **Properties** * frame : `Point3d` * size : `Vector2d` * keep aspect ratio : `Bool` * transparency : `Range` **Inputs** * texture : `Texture` * frame : `Point, Vector, Plane` * size : `Number, Point, Vector` * keep aspect ratio : `Bool` * transparency : `Number` **Clip** Display geometry with a clipping plane **Properties** * origin : `Point3d` * direction : `Vector3d` **Inputs** * geometry : `Curve, Surface, Brep, Mesh, Box, VolumeMesh` * clip plane : `Plane` **Preview** Build a display material from diffuse color, transparency (0..1), shine (0..1), and emission color. **Properties** * diffuse : `Color` * transparency : `Range` * shine : `Range` * emission : `Color` **Inputs** * diffuse : `Color` * transparency : `Number` * shine : `Number` * emission : `Color` **Outputs** * material : `Material` Render a list of geometries (Mesh / Curve / Surface / Brep / VolumeMesh) and/or Implicit (SDF) inputs in the viewport with a shared custom display material. **Inputs** * geometry : `Curve, Surface, Brep, Mesh, Box, Implicit, VolumeMesh` * material : `Material` **Color** Map a list of scalar values to colors using a built-in colormap **Properties** * colormap : `Category` **Inputs** * values to map : `Number` * domain to remap from (defaults to min/max of input) : `Domain` * colormap : `Number` **Outputs** * colors : `Color` Build an RGB color from channel values. When `normalized` is true, inputs are interpreted as 0..1; otherwise 0..255. **Properties** * r : `Number` * g : `Number` * b : `Number` * normalized : `Bool` **Inputs** * r : `Number` * g : `Number` * b : `Number` * normalized : `Bool` **Outputs** * color : `Color` Split a color into its R, G, B channels. When `normalized` is true, outputs are 0..1 floats; otherwise 0..255. **Properties** * normalized : `Bool` **Inputs** * color : `Color` * normalized : `Bool` **Outputs** * r : `Number` * g : `Number` * b : `Number` **Analysis** Visualize a stress solver's result: display the implicit surface coloured by a selected field, with a viewport legend **Properties** * field : `String` * color map : `Category` * transparency : `Range` **Inputs** * implicit (optional) : `Implicit` * fields : `Field` * field name : `String` * transparency : `Number` Visualize boundary conditions (Fixed, Force, Pressure) from implicit analysis **Properties** * display scale : `Number` **Inputs** * configurations : `Analysis` * display scale : `Number` ## Field **Analysis** Deconstruct a Field into its name, bbox, resolution, voxel size, and components **Inputs** * field : `Field` **Outputs** * name : `String` * bbox : `Box` * resolution : `Vector` * voxel size : `Vector` * components : `Number` **Utils** Select a named field out of a list of fields (e.g. solver output) **Properties** * name : `String` **Inputs** * fields : `Field` * field name : `String` **Outputs** * field : `Field` ## Sets **List** Dispatch a list based on a pattern **Inputs** * list to dispatch : `Any` * dispatch pattern (default: \[true, false]) : `Number, Bool` **Outputs** * culled list : `Any` * rest list : `Any` Insert items into a list at specified indices **Properties** * wrap : `Bool` **Inputs** * list to modify : `Any` * items to insert : `Any` * insersion index : `Number, Bool` * indices will be wrapped or not : `Bool` **Outputs** * modified list : `Any` Get the index of an item in a list **Inputs** * list to search : `Any` * item to search for : `Any` **Outputs** * the index of item in the list * -1 if not found : `Number` Get an item from a list **Properties** * index : `Number` **Inputs** * base list : `Any` * index : `Number` **Outputs** * item at index : `Any` Get the number of items in a list **Inputs** * base list : `Any` **Outputs** * number of items : `Number` Partition a list into chunks **Inputs** * list to partition : `Any` * size of partitions : `Number` **Outputs** * list chunks : `Any` Reverse the order of items in a list **Inputs** * list to reverse : `Any` **Outputs** * reversed list : `Any` Shift the items in a list by a given offset **Properties** * offset : `Number` * wrap : `Bool` **Inputs** * list to shift : `Any` * offset : `Number` * wrap : `Bool` **Outputs** * shifted list : `Any` Sort the items in a list **Inputs** * sort keys : `Number` * values to sort : `Any` **Outputs** * sorted keys : `Number` * sorted values : `Any` Weave multiple lists into one list **Inputs** * patterns as list (default: \[0, 1]) : `Number, Bool` * input stream at index 0th : `Any` * input stream at index 1th : `Any` **Outputs** * weave result : `Any` **Sequence** Cull items from a list by index **Properties** * culling index : `Number` * wrap : `Bool` **Inputs** * list to cull : `Any` * culling indices : `Number` * wrap indices to list range : `Bool` **Outputs** * culled list : `Any` * rest list : `Any` Cull items from a list based on a pattern **Inputs** * list to cull : `Any` * culling pattern : `Number, Bool` **Outputs** * culled list : `Any` * rest list : `Any` Generate random numbers **Properties** * domain : `Vector2d` * count : `Number` * seed : `Number` * integer : `Bool` **Inputs** * domain of random numeric range : `Number, Domain` * number of random values : `Number` * seed of random values : `Number, Point, Vector` **Outputs** * random numbers : `Number` Generate a sequence of numbers within a range **Properties** * range : `Vector2d` * step : `Number` **Inputs** * domain of numeric range : `Number, Domain` * number of steps : `Number` **Outputs** * range numbers : `Number` Generate a series of numbers **Properties** * start : `Number` * step : `Number` * count : `Number` **Inputs** * start : `Number` * step : `Number` * count : `Number` **Outputs** * result series : `Number` **Text** Concatenate text fragments **Properties** * separator : `String` **Inputs** * 0th text fragment : `String` * 1th text fragment : `String` **Outputs** * concat text : `String` Join text fragments **Properties** * separator : `String` **Inputs** * text fragments to join : `String` * separator : `String` **Outputs** * joined text : `String` **Tree** Flatten a data tree **Inputs** * data tree to flatten : `Any` **Outputs** * flattened data tree : `Any` Flip a data tree **Inputs** * data tree to flip : `Any` **Outputs** * flipped data tree : `Any` Graft a data tree **Inputs** * data tree to graft : `Any` **Outputs** * grafted data tree : `Any` Merge data trees **Inputs** * 0th target : `Any` * 1th target : `Any` **Outputs** * merged output : `Any` Shift paths in a data tree **Properties** * offset : `Number` **Inputs** * data tree to shift : `Any` * number of offset : `Number` **Outputs** * shifted data tree : `Any` Simplify a data tree **Inputs** * data tree to simplify : `Any` **Outputs** * simplified data tree : `Any` Split a data tree based on a set of masks **Properties** * mask : `String` **Inputs** * data tree to split : `Any` * splitting masks : `String` **Outputs** * positive set of data (all branches that match any of the masks) : `Any` * negative set of data (all branches that do not match any of the masks) : `Any` Filter a stream based on a gate stream **Properties** * index : `Number` **Inputs** * index of gate stream : `Number, Bool` * input stream at index 0th : `Any` * input stream at index 1th : `Any` **Outputs** * filtered stream : `Any` Gate a stream based on a gate index **Properties** * index : `Number` **Inputs** * input stream : `Any` * gate index of output stream : `Number, Bool` **Outputs** * output for gate index 0 : `Any` * output for gate index 1 : `Any` Reduce the complexity of a data tree by merging the outermost branches **Properties** * depth : `Number` **Inputs** * data tree to trim : `Any` * depth : `Any` **Outputs** * trimmed data tree : `Any` ## Params **Primitive** Create a boolean value **Properties** * value : `Bool` **Inputs** * input : `Number, Bool, String` **Outputs** * output : `Bool` Create a number value **Properties** * value : `Number` * integer : `Bool` * precision : `Number` **Inputs** * value : `Number, Bool, String` * integer or not : `Bool` **Outputs** * output value : `Number` **Geometry** Create a curve from geometry **Inputs** * input geometry : `Curve, Surface, Brep` **Outputs** * curve : `Curve` Create a point from geometry **Inputs** * input data : `String, Point, Vector` **Outputs** * point : `Point` **Input** Map input value to output value using a graph **Properties** * control points : `Points2d` * mapping : `Category` **Inputs** * input value : `Number` **Outputs** * output value : `Number` Map a 2D point (0.0 \~ 1.0) to a 3D point with x, y domain **Properties** * x range : `Vector2d` * y range : `Vector2d` * step : `Vector2d` * value : `Vector2d` **Inputs** * x range : `Number, Domain` * y range : `Number, Domain` **Outputs** * output 3d point : `Point` Output a number within a domain **Properties** * range : `Vector2d` * step : `Number` * value : `Number` **Outputs** * output value : `Number` Output a string or a list of strings if multi line is true. **Properties** * content : `String` * multi line : `Bool` **Outputs** * output value : `String` **Import** Import geometry from a buffer **Properties** * buffer : `Buffer` * file name : `String` * format : `Category` **Outputs** * imported geometry : `Point, Curve, Surface, Brep, Mesh, VolumeMesh` Import texture from a buffer **Properties** * buffer : `Buffer` * file name : `String` * format : `Category` **Outputs** * imported texture : `Texture` **Export** Export Brep or surfaces to STEP/IGES file **Properties** * file name : `String` * format : `Category` **Inputs** * brep or surfaces : `Surface, Brep` * file name : `String` * format (0: step, 1: iges) : `Number` Export curves to file **Properties** * file name : `String` * format : `Category` **Inputs** * curves : `Curve` * file name : `String` * format (0: dxf, 1: svg, 2: json) : `Number` Export meshes to file **Properties** * file name : `String` * format : `Category` **Inputs** * meshes : `Mesh` * file name : `String` * format (0: stl, 1: obj, 2: gltf, 3: glb, 4: ply, 5: 3mf, 6: json) : `Number` Export points to file **Properties** * file name : `String` * format : `Category` **Inputs** * points : `Point` * file name : `String` * format (0: txt, 1: csv, 2: tsv, 3: json) : `Number` Export surfaces to file **Properties** * file name : `String` * format : `Category` **Inputs** * surfaces : `Surface` * file name : `String` * format (0: stl, 1: obj, 2: gltf, 3: glb, 4: ply, 5: 3mf, 6: step, 7: iges, 8: json) : `Number` * meshing quality settings : `Quality` Export a texture to an image file **Properties** * file name : `String` * format : `Category` **Inputs** * texture : `Texture` * file name : `String` * format (0: png, 1: jpeg, 2: bmp, 3: tiff) : `Number` **Utils** Export a text file. **Properties** * file name : `String` **Inputs** * input : `Any` * file name : `String` **Outputs** * output : `Any` Relay the input to the output **Inputs** * input : `Any` **Outputs** * output : `Any` Sub Graph **Properties** * instance\_id : `String` Sub Graph Input **Properties** * index : `Number` **Outputs** * output : `Any` Sub Graph Output **Properties** * index : `Number` **Inputs** * input : `Any` Unknown or unrecognized node type **Properties** * variant : `String`