Model - transforms & modifiers
Every transform / modifier — it consumes the stream flowing into it and returns the stream flowing out. Authored as a step in an objects[] chain, after the producers whose entities it acts on.
| Method | Description | Arg | Type | Default | Meaning |
|---|---|---|---|---|---|
applyAttribute | Attribute | key | string | 'type' | Attribute name to set (single-quote literal), e.g. 'type' or 'ifcClass'. |
value | string | function | '' | Value to store under that key (single-quote literals), or a callback (entity, index) => value, per entity. | ||
applyLabel | Label | name | string | function | '' | Display/export label tag (single-quote literals), or a callback (entity, index) => string, per entity. |
applyLayer | Layer | name | string | function | 'Layer1' | Layer name to assign (single-quote literals), or a callback (entity, index) => string, per entity. |
applyLocked | Locked | locked | binary | function | true | true shields the entities from every later step of this chain; or a callback (entity, index) => boolean, per entity. |
applyMaterial | Material | name | material | function | '' | A materials[] record name to assign (single-quote literals), or a callback (entity, index) => string, per entity. |
applyView | View | family | string | function | 'plan' | View family this entity belongs to (single-quote literal): '3d' (default — the projection/section body), 'plan', 'section', 'elevation', 'pattern', or 'detail'. A views[] entry draws the entity when its family matches (entity view is drawn in view V ⟺ X equals V's family from the head method — VIEW_FAMILY_OF map); non-'3d' content is authored drawing content, never projected or sectioned. |
applyVisible | Visible | visible | binary | function | true | true shows, false hides the entities; or a callback (entity, index) => boolean, per entity. |
arrayCurve | Array Along NurbsCurve | curve | curveEntity | Path curve the copies are distributed along. | |
copies | number | 4 | Copies to add along the curve — original at the start, spaced evenly. | ||
angle | angle | 0 | Extra rotation in degrees applied to each copy about the curve tangent. | ||
arrayDistances | Array by Distances — Copies along Direction at explicit per-gap distances (cumulative — gap 1, then gap 2 after it, …). Use arrayLinear when the spacing is uniform. | direction | vector | [1,0,0] | Direction to array along — magnitude ignored, see Distances for spacing. |
distances | length[] | [300,400,500] | Gap after each copy, in order, along Direction. Copy count = number of distances (a partition — no separate Copies arg). | ||
arrayLinear | Linear Array | vector | vector | [100,0,0] | Per-copy step — magnitude IS the spacing (unlike Array Along Distances, where direction is normalized). |
copies | number | 2 | Copies to add — the original stays, so 1 duplicates once. | ||
arrayRadial | Radial Array | axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Rotation axis: origin = pivot point, direction = spin axis. |
copies | number | 5 | Copies to add around the axis — original + copies spaced evenly over 360°. | ||
bend | Bend | axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Bend spine: the geometry's extent along this axis maps onto a circular arc. |
angle | angle | 90 | Total arc angle in degrees (90 = quarter turn). | ||
resolution | number | 24 | Tessellation density before deforming. | ||
blockExplode | Explode | nested | binary | 1 | Dissolve this node's nested blocks (a placed sub-model / clone) into raw geometry. 1 = recursive; 0 = one level. |
curveChamfer | NurbsCurve Chamfer | distance | length | 5 | Straight setback from each selected corner (flat cut, not an arc). |
filter | function | (p, i) => true | Predicate over a corner vertex and its index selecting which to cut; default = all. | ||
curveExtrude | Extrude — Push the chain's curves into solids — a closed loop gets caps, an open one becomes walls. | thickness | length | 10 | Extrusion distance along the profile's normal. |
caps | binary | 1 | 1 = closed profiles get top/bottom caps (a solid); 0 = walls only (open shell). | ||
curveFill | Fill — Fill the chain's closed curves into flat faces — a closed curve nested inside another becomes a hole; open curves pass through. | ||||
curveFillet | NurbsCurve Fillet | radius | length | 5 | Arc radius rounding each selected corner (curved). |
filter | function | (p, i) => true | Predicate over a corner vertex and its index selecting which to round; default = all. | ||
curveIntersect | NurbsCurve Intersect | curve | curveEntity | The closed curve to keep only the overlap with (2D boolean). | |
curveLoft | Loft — Skin a surface through the chain's curves in order (2 or more) — array a profile into sections, then loft them in one chain. | degree | number | 3 | Smoothness across sections: 1 = straight (ruled) between curves, 3 = smooth. |
curveOffset | Offset NurbsCurve — Offsets every curve in the chain's own array — coplanar curves are grouped first and offset together (shapes that grow into overlap merge; a shape's holes inset/outset with its outer loop), non-coplanar groups offset independently. | distance | length | 10 | Offset amount: positive = outward, negative = inward. |
curveOvercut | NurbsCurve Overcut — CNC corner-clearance relief (dogbone/T-bone): adds an arc extending past selected corners so a round cutting tool still seats a square mating part. Throws if radius/reduction are invalid. | radius | length | 5 | Relief arc radius — match the cutting tool radius. |
type | string | 'dogbone' | 'dogbone' bulges into both adjacent edges symmetrically. 'longTbone'/'shortTbone' extend into only the longer/shorter adjacent edge, keeping the other exact. | ||
reduction | length | 0 | 0..radius — pulls the relief toward the vertex; at reduction === radius the arc passes exactly through the vertex. | ||
filter | function | (p, i) => true | Predicate over a corner vertex and its index selecting which to relieve; default = all. | ||
curvePatch | Patch — Fill the chain's boundary curve(s) with a smooth surface — chains off the boundary, so no separate curve node to hide. | ||||
curveProject | Project Onto Mesh — Drape the chain's curve onto a target mesh — each point is cast along the direction and snapped to the nearest surface hit. Mesh-level. | target | faceEntity[] | [] | The mesh (Face[]) to project onto. |
direction | vector | [0,0,-1] | Cast direction (default straight down = drape onto terrain). | ||
curveRevolve | Revolve — Spin the chain's curve(s) about an axis into a solid — a closed profile yields a solid of revolution. Chains off the profile, so no separate curve node to hide. | axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Revolution axis (origin on the axis, direction = spin axis). |
angle | angle | 360 | Sweep in degrees: 360 = full solid, under 360 = partial. | ||
curveSelfUnion | NurbsCurve Self Union — Fuse all closed curves in the node's own array into one region (2D boolean union, no operand). | ||||
curveSimplify | Simplify NurbsCurve — Douglas-Peucker vertex reduction: drops points that stay within Tolerance of the simplified polyline. Endpoints are always kept (open curves); closed curves split at 3 well-spread anchor points first so the result never opens up. | tolerance | length | 1 | Max deviation allowed between a dropped point and the simplified polyline. |
curveSmooth | Smooth NurbsCurve — Chaikin corner-cutting: rounds every corner by iteratively replacing it with two points partway along its adjacent edges. Closed curves round all the way around; open curves keep their exact endpoints. Output is always a degree-1 polyline. | iterations | number | 2 | Corner-cutting passes: each doubles the vertex count and rounds corners further. |
curveSplit | NurbsCurve Split | parameter | number | 0.5 | Normalized split position from start (0) to end (1). |
curveSubtract | NurbsCurve Subtract | curve | curveEntity | The closed curve to cut away from this one (2D boolean). | |
curveSweep | Sweep — Sweep the chain's profile curve along a path into a solid tube — the profile is this chain, the path is the argument. | path | curveEntity | [] | Path the profile is swept along (open or closed curve). |
caps | binary | 1 | Close the two ends of the swept tube (false = open duct). | ||
curveThicken | Thicken NurbsCurve — Thickens every curve in the chain's own array into a closed strip — coplanar curves are grouped first and thickened together, non-coplanar groups independently. | distance | length | 10 | Offset applied to EACH side of the curve — the strip is twice this wide. |
joinType | string | 'miter' | How outer corners are joined: 'round' (arc), 'miter' (sharp point), 'square' (clipped). | ||
endType | string | 'round' | How open ends are capped: 'round' (semicircle), 'square' (half-width), 'butt' (flush). | ||
curveUnion | NurbsCurve Union | curve | curveEntity | The closed curve to merge with this one (2D boolean). | |
displace | Displace | field | string | '' | Key of a textures[] chain to sample (triplanar); 0.5 is the neutral level. |
amount | length | 1 | Displacement along the surface normal at field value 1 (negative at 0). | ||
tile | length | 10 | Physical size (mm) of one field tile on the surface. | ||
resolution | number | 48 | Tessellation density: vertices available for the field to shape. | ||
edgeFillet | Edge Fillet — Rounds selected edges by welding faces to mesh, discretizing the neighborhood into planar facets (segments), then returning face entities. Not a true NURBS fillet (kernel roadmap). | filter | function | (p1, p2) => true | Predicate over an edge's two endpoints selecting which edges to round; default = all. |
radius | length | 2 | Rolling-ball arc radius of the rounded edge (curved). | ||
segments | number | 12 | Number of planar facets across the arc; higher = smoother (discretized, not NURBS). | ||
faceContours | Face Contours — Slice the chain's faces at evenly spaced Z levels into iso-elevation contour curves — REPLACES the sliced faces with the contours (reference the previous step's key to keep the surface itself). Non-face entities and nested blocks pass through untouched. | spacing | length | 500 | Elevation interval between contour levels. |
base | number | 0 | Z of the reference contour level; other levels are base ± k*spacing. | ||
faceEdgeDissolve | Dissolve Edges — Fuse the two coplanar faces sharing each selected edge into one polygon (erase the edge). Merges triangles/quads back into n-gons. | filter | function | (p1, p2) => true | Predicate over an edge's two endpoints [x,y,z]; default fuses every coplanar shared edge. |
faceExtrude | Face Extrude | thickness | length | 10 | Distance to push the selected faces along their normal (negative = inward). |
filter | function | (points, normal) => true | Predicate over a face's points and normal selecting which faces to push; default = all. | ||
faceOffset | Offset Face | distance | length | 10 | Inset (positive) or outset (negative) distance. |
facePlanarize | Planarize — Nudge shared panel corners until every panel is flat — a warped quad tessellation becomes panels cuttable from flat sheet material, changing the surface as little as possible. Triangles are already planar and act as anchors. | pin | function | (point) => false | Predicate over a vertex's ORIGINAL point selecting which ones must not move (e.g. a fixed boundary); default = none. |
faceSkeleton | Bind Skeleton — Bind face vertices to a skeletons[] chain: nearest bone segments, top-4 influences, smooth falloff over Falloff mm, weights sum to 1. Writes geometry.skin. Deterministic. Re-running with a different falloff changes the transition width. | skeleton | string | '' | skeletons[] chain key (single-quote literal). |
falloff | length | 80 | Influence radius in mm — weight falls to 0 beyond this distance from the nearest bone segment. | ||
faceSplit | Face Split | curves | curveEntity[] | [] | Curves drawn on a coplanar face — circle/arc/spline/polyline, one or more. Closed curves = an inner face + the outer carrying them as a hole (nested rings become holes); one open curve with both ends on the boundary = the face splits in two. |
faceToMesh | Faces → Mesh — Convert the chain's faces into ONE meshEntity — the canonical step onto the mesh track. Planar faces without holes become one n-gon each (design edges preserved for lattice/wireframe); curved faces tessellate and pair into quads. The sanctioned path: parametric body → Faces → Mesh → Mesh Subdivision. One-way: no op converts a mesh back into faces. | ||||
faceTrim | Trim Face — Trim each planar face by a coplanar curve/face region — keep the part inside the tool, or cut it out. Mesh-level (flat faces). | tool | curveEntity[] | faceEntity[] | [] | The coplanar closed region to trim with. |
side | binary | 1 | Which side of the tool survives: 1 = inside (intersect); 0 = outside (cut the tool out). | ||
faceUnfold | Unfold — Flatten a curved panel into a 2D cutting pattern — for cutting the material a curved surface represents. Each output triangle carries an attributes.areaDistortion (2D area ÷ 3D area — 1 = undistorted; far from 1 = untrustworthy to cut there). Any curved panel flattens, developable or not. | ||||
keepEntities | Keep Entities — Keep only the entities for which the predicate is truthy — the general delete/filter (by region or type). Nested blocks pass through. | keep | function | (center, type, index) => true | Predicate over each entity's bbox center [x,y,z], its type (curveEntity/faceEntity/...), and index. Return false to delete it. |
looseToBlock | Loose to Blocks — Collect loose curves/faces into blocks by connectivity — each connected cluster becomes one nested block (inverse of Explode). | ||||
makeBlock | Make Block — Wrap the whole entity array into one nested block, unconditionally — no connectivity clustering (unlike Loose to Blocks, which makes one block per connected cluster). | ||||
meshLattice | Mesh Lattice — Hollow every meshEntity in the stream into a strut frame — each polygon face is inset and the remaining rims thicken into struts along design edges (no triangulation diagonals). Needs the welded shell struts meet across, so it works on meshes: convert first with Faces → Mesh. Meshes only — faces and curves pass through untouched. | thickness | length | 2 | Strut/wall thickness of the lattice shell. |
boundary | binary | 1 | Close the open border edges of the lattice with caps. | ||
meshSubdivision | Mesh Subdivision — Catmull-Clark-subdivide every meshEntity in the stream — each pass smooths the surface and turns every n-gon into n quads. Normals are rebuilt smooth; uv/color/skin channels do not survive. Meshes only — faces and curves pass through untouched (convert first with Faces → Mesh). | iterations | number | 1 | Catmull-Clark passes: each smooths the mesh and turns every n-gon into n quads. |
mirror | Mirror | plane | plane | { point: [0,0,0], normal: [1,0,0] } | Mirror plane (point on plane + normal). |
clone | binary | 1 | 1 keeps the original and adds the reflection; 0 flips in place. | ||
move | Move | vector | vector | [0,0,1] | Displacement to apply. |
resize | Resize | sizeX | length | function | 1 | Target width along X, or a callback (entity, index) => number, per entity. |
sizeY | length | function | 1 | Target depth along Y, or a callback (entity, index) => number, per entity. | ||
sizeZ | length | function | 1 | Target height along Z, or a callback (entity, index) => number, per entity. | ||
reverse | Reverse — Flip direction — curve order / face normal, per entity type. | ||||
rotate | Rotate | axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Rotation axis (origin = pivot point, direction = axis; magnitude irrelevant). |
angle | angle | function | 0 | Rotation angle in degrees (CCW about the axis), or a callback (entity, index) => number, per entity. | ||
scatter | Scatter — Randomly distribute copies across a face's surface — area-weighted, aligned to the face normal, randomly spun. Deterministic: the same Seed always samples the same points. | face | faceEntity[] | [] | Surface(s) to scatter across. |
copies | number | 20 | Copies to add — the source is planted at (copies + 1) sampled points, same convention as Array Along NurbsCurve. | ||
seed | number | 0 | Change to reshuffle the random placement while staying repeatable. | ||
solidify | Solidify (Shell) — Hollows a solid via mesh weld + offset (discretized faces returned). Remove faces first to open a shell. | thickness | length | 3 | Hollow the solid to a wall this thick, offset inward from the surface. A closed solid becomes a sealed hollow shell; remove faces first (Face Extrude inward, or delete) to open it. |
solidIntersect | Solid Intersect | solid | faceEntity[] | The closed solid (Face[]); keeps only the volume shared by both (3D CSG). | |
solidSelfUnion | Solid Self Union — Fuse all closed solids (Face[]) in the node's own array into one solid (3D CSG, no operand). | ||||
solidSlice | Slice | plane | plane | { point: [0,0,0], normal: [0,0,1] } | Cut everything in the stream (faces + curves) with this plane. Returns the two sides as separate groups — nothing is deleted; drop a side with Visible or a filter. |
cap | binary | 1 | 1 fills the cross-section so each piece stays closed; 0 leaves the cut open. | ||
solidSubtract | Solid Subtract | solid | faceEntity[] | The closed solid (Face[]) to carve out of this one (3D CSG). | |
solidUnion | Solid Union | solid | faceEntity[] | The closed solid (Face[]) to fuse with this one (3D CSG). | |
taper | Taper | axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Taper axis: scaling shrinks/grows perpendicular to this spine. |
factor | number | 0.5 | Radial scale at the far end (1 = none, 0 = to a point). | ||
resolution | number | 24 | Tessellation density before deforming. | ||
textOnPath | Text On Path — Lay text glyphs ALONG the chain's path curve — the baseline follows the curve, glyphs bending with it. The chain IS the path and is consumed (output is glyphs only, no guide curve). | text | string | 'Hello' | The string to render along the path; single-quote the literal. |
font | font | Font reference; leave '' to use the built-in fallback font. | |||
fontSize | length | 10 | Cap height of the glyphs in model units. | ||
twist | Twist | axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Twist axis: origin = pivot, direction = spine. |
angle | angle | 90 | Total twist in degrees across the geometry's extent along the axis. | ||
resolution | number | 24 | Tessellation density before deforming (higher = smoother, heavier). | ||
vertexDelete | Delete Vertices — Delete selected vertices — curves rebuild from survivors; faces use weld-aware mesh delete (input-type dispatch). | filter | function | (point) => false | Predicate over a point [x,y,z] to delete; default deletes none. |
vertexFillet | Vertex Fillet — Rounds selected vertices by welding to mesh and discretizing into planar faces (same mesh path as edgeFillet; true NURBS fillet is kernel roadmap). | filter | function | (point) => true | Predicate over a vertex's point selecting which corners to round; default = all. |
radius | length | 2 | Rolling-ball arc radius of the rounded corner (curved). An unselected neighbor vertex is left untouched. | ||
segments | number | 12 | Number of facets across the arc; higher = smoother. | ||
vertexMove | Move Vertices — Move selected vertices — curve control points or face mesh vertices (input-type dispatch; welded faces move together). | filter | function | (point) => true | Predicate over a point [x,y,z]; default selects all. |
vector | vector | [0,0,0] | Translation applied to selected vertices. | ||
vertexRotate | Rotate Vertices — Rotate selected vertices about an axis — curves and faces (input-type dispatch). | filter | function | (point) => true | Predicate over a point [x,y,z]; default selects all. |
axis | axis | { origin: [0,0,0], direction: [0,0,1] } | Rotation axis (origin on the axis, direction = spin axis). | ||
angle | angle | 0 | Rotation in degrees. | ||
vertexScale | Scale Vertices — Scale selected vertices about a center — curves and faces (input-type dispatch). | filter | function | (point) => true | Predicate over a point [x,y,z]; default selects all. |
center | point | [0,0,0] | Fixed point the scale is measured from. | ||
factor | number | 1 | Uniform scale factor. |