Modify#

Modeling operations: extrude, bevel, boolean, clip, fuse, remesh, subdivide and friends.

76 nodes.

Back to the reference index

Contents#

• Blast (PCG) — Deletes the elements in a group, or keeps only those elements.
• Blast by Attribute (PCG) — Deletes points or primitives by comparing a single-valued attribute against a threshold, range or band, or just groups the hits.
• Boolean (PCG) — Combines two closed meshes with a union, intersection, subtraction, shatter or seam operation.
• Boolean Fracture (PCG) — Cuts the first input into separate pieces using the second input as the cutting geometry.
• Bound (PCG) — Builds a bounding box, bounding sphere or minimum-volume oriented box around the geometry.
• Carve (PCG) — Cuts a curve at parametric positions or extracts points along it.
• Circle from Edges (PCG) — Rearranges each closed edge loop in a group into a perfect circle.
• Circle Spline (PCG) — Creates a smooth curve through the input points by blending circular arcs fitted to each three neighbouring points.
• Clean (PCG) — Repairs a polygon mesh by fusing points, removing degenerate and duplicate faces, fixing non-manifold edges and orientation, and dropping small pieces.
• Clip (PCG) — Cuts geometry with a plane and keeps the part below it, above it, or both.
• Convert (PCG) — Converts primitives between polygon, polyline, point, NURBS, Bezier and volume representations.
• Convex Decompose (PCG) — Splits a concave solid into a set of convex pieces (approximate convex decomposition).
• Convex Hull (PCG) — Builds the 3D convex hull of the input points.
• Crease (PCG) — Writes a fractional crease weight onto edges for later subdivision.
• Curve Fillet (PCG) — Rounds polyline corners with circular arcs.
• Curve Intersect (PCG) — Finds intersections between curves and outputs points, split curves, or Houdini-style cut and extract results.
• Delete (PCG) — Deletes points, primitives or edges chosen by group, number, bounding volume, normal, degeneracy, random chance or an expression.
• Dissolve (PCG) — Removes selected edges and merges the faces on either side of them into one.
• Divide (PCG) — Triangulates or splits faces into convex polygons, cuts them into bricks, merges shared edges, or computes the dual.
• Edge Collapse (PCG) — Collapses each connected run of selected edges into a single point at the run's center.
• Edge Divide (PCG) — Inserts points on selected edges and optionally connects them to split the faces.
• Edge Equalize (PCG) — Evens out edge lengths along edge chains, either by redistributing points along the polyline or by Houdini's target-length methods.
• Edge Straighten (PCG) — Pulls each open chain of selected edges into a straight line, keeping its end points fixed.
• Ends (PCG) — Closes, opens, unrolls or rolls curves.
• Exploded View (PCG) — Moves fracture pieces apart from each other so cuts can be inspected.
• Extract Transform (PCG) — Computes the best-fit transform from a reference geometry to a deformed or moved copy of it.
• Facet (PCG) — Runs a fixed chain of topology cleanup and hard-edge options: unique points, consolidate, orient, cusp, inline and degenerate removal, normals.
• Fracture Detail (PCG) — Adds noise to the cut (interior) faces of fracture pieces while keeping the pieces fitting together.
• Fuse (PCG) — Snaps nearby points together (to each other, to a grid, or to a target) and optionally welds them into single points.
• Intersection Analysis (PCG) — Places a point wherever triangles or polylines pass through each other and records their sources.
• Join (PCG) — Connects the selected polylines in order into one polyline, bridging gaps with straight segments.
• Loop Cut (PCG) — Inserts a complete edge loop through quads, starting from seed edges.
• Match Axis (PCG) — Rotates geometry by the smallest rotation that takes one axis direction onto another.
• Match Size (PCG) — Moves and scales geometry to fit a reference box, and can stash the transform so it can be undone later.
• Merge (PCG) — Combines up to six geometries into one.
• Mirror (PCG) — Mirrors geometry about a plane, optionally keeping the original and welding the seam.
• Peak (PCG) — Moves points along their normals by a distance.
• Point Jitter (PCG) — Adds random displacement to points.
• Point Split (PCG) — Splits points whose vertices carry different values of a vertex attribute into separate points.
• Poly Bridge (PCG) — Builds a surface of polygons between two loops of edges, such as a tunnel or handle.
• PolyBevel (PCG) — Bevels edges of polygon geometry with an optional rounded, chamfered, solid or crease profile.
• PolyDoctor (PCG) — Detects and optionally repairs common polygon problems, writing validity flags.
• PolyExpand2D (PCG) — Offsets a planar curve network inward and outward by a constant distance.
• PolyExtrude (PCG) — Extrudes polygons along their normals, a fixed direction or a spine curve, with inset, twist and divisions.
• PolyFill (PCG) — Closes open boundary loops with new polygons.
• PolyPath (PCG) — Joins polylines whose end points touch into the longest possible curves, without creating any edges.
• PolyReduce (PCG) — Reduces triangle or point count with quadric error edge collapse.
• PolySpline (PCG) — Converts polylines into smooth spline curves sampled as polylines.
• Primitive (PCG) — Transforms each selected primitive around its own center and offsets it along its normal.
• Primitive Split (PCG) — Splits shared points so that primitives with different attribute values no longer share them.
• Ray (PCG) — Projects points onto collision geometry by ray casting or by nearest surface point.
• Refine (PCG) — Inserts, removes or subdivides points along curves at parametric positions.
• Remesh (PCG) — Rebuilds a triangle mesh with uniform, isotropic triangles of a target edge length.
• Remesh to Grid (PCG) — Rebuilds a surface as a closed all-quad mesh from a voxelised signed distance field.
• Resample (PCG) — Resamples curves into evenly spaced points by length or segment count.
• Reverse (PCG) — Reorders the vertices of primitives: reverse, swap U/V or shift.
• Shrinkwrap (PCG) — Wraps geometry in a single closed manifold shell by rolling a sphere over it from outside.
• Smooth (PCG) — Applies Laplacian smoothing to points and other attributes.
• Sort (PCG) — Reorders points and primitives by position, attribute, expression or other criteria without changing the shape.
• Split (PCG) — Splits geometry into the part in a group and the part outside it.
• Subdivide (PCG) — Subdivides polygon meshes with Catmull-Clark, Loop or bilinear schemes.
• Switch (PCG) — Passes through one of up to eight inputs, chosen by index or expression, evaluating only the selected branch.
• Switch-If (PCG) — Outputs one of two inputs depending on whether a set of tests passes.
• Thicken (PCG) — Gives open surfaces a thickness with a second skin and side walls.
• Transform (PCG) — Translates, rotates, scales and shears points with a Houdini-style transform and pivot.
• Transform by Attribute (PCG) — Transforms geometry by matrix attributes, per detail, point or primitive.
• Triangulate 2D (PCG) — Builds a Delaunay or constrained Delaunay triangulation of points lying in a plane.
• Volume Blur (PCG) — Blurs volumes with a Gaussian or box filter, or reduces neighbourhoods with min, max, median and similar operators.
• Volume Mix (PCG) — Combines volumes of two inputs on the grid of the first, with arithmetic, blending or SDF boolean operations.
• Volume Resample (PCG) — Changes the resolution of volumes while keeping their bounding box.
• Volume Reshape SDF (PCG) — Dilates, erodes, opens, closes or redistances signed distance field volumes.
• Volume Smooth SDF (PCG) — Smooths SDF volumes with mean, median, mean curvature flow or Laplacian flow filters.
• Volume Wrangle (PCG) — Runs wrangle code with each voxel as one element.
• Voronoi Cluster (PCG) — Groups Voronoi pieces into larger clusters and optionally glues each cluster into one piece.
• Voronoi Fracture (PCG) — Cuts geometry into pieces around seed points, with interior caps, piece names and attributes.
• Voronoi Split (PCG) — Cuts a surface along the Voronoi cell borders of the cell points.

Nodes#

Blast (PCG)#

PCG_Blast · category PCG/modify · Houdini: Blast (SOP)

Deletes the elements in a group, or keeps only those elements.

Removes the points or primitives selected by the group pattern. With Delete Non Selected the selection is inverted and only the group is kept.

Inputs

Outputs

Parameters

Blast by Attribute (PCG)#

PCG_BlastByAttribute · category PCG/modify · Houdini: Blast by Attribute (SOP)

Deletes points or primitives by comparing a single-valued attribute against a threshold, range or band, or just groups the hits.

Tests a scalar numeric attribute on each element and either deletes the elements that match or, with Output = Group, leaves the geometry intact and puts the matching elements into a new group.

Modes:

• Threshold: matches elements whose value is strictly below the threshold (equal values stay).
• Range: matches min <= value <= max.
• Width: matches values inside [center - width/2, center + width/2].

Invert flips the match. Elements outside the Group are never tested, and Invert does not touch them either. Vector attributes are rejected with an error.

Inputs

Outputs

Parameters

Compared with Houdini

The defaults of the numeric parameters are the plugin's own choice, since the SideFX documentation does not state them. Vector attributes are an error here.

Boolean (PCG)#

PCG_Boolean · category PCG/modify · Houdini: Boolean (SOP), Intersection Stitch (SOP)

Combines two closed meshes with a union, intersection, subtraction, shatter or seam operation.

Boolean operations on polygon meshes, backed by the manifold3d library rather than a hand-written implementation: robust booleans need exact predicates, coplanar handling, re-triangulation of intersection curves and winding-number classification, and a failure would crash on the user's model.

Both inputs must be closed manifold meshes. When they are not, the node reports the reason and where to look.

With Detriangulate on, adjacent triangles whose normals differ by less than Coplanar Tolerance are merged back into one polygon. Optional output groups mark where each piece of the result came from.

Shatter outputs three pieces: A intersect B, A minus B and B minus A, sharing no points (separate them with connectivity). Seam outputs only the intersection curve as open polylines. A set treated as Surface is thickened into a closed shell by extruding it against its normals (the original faces stay in place), and after the operation only the faces lying on the original surface are kept.

Point, vertex and primitive attributes and groups of A and B are carried to the result. Each output triangle finds the input face it was cut from; floating-point point and vertex attributes are interpolated barycentrically inside that face, integer and string values and group membership come from the nearest corner, and primitive attributes and groups come from the face. An attribute that exists on only one input is 0 (or an empty string) on the other input's faces; when A and B use the same name with a different type or size, A's version is kept. Edge groups are not carried, because the edges are cut.

Inputs

Outputs

Parameters

Set A

Set B

Surface

Detriangulate

Output Groups

Compared with Houdini

The B Polygons output group does not exist on the Houdini node; it is an addition of this plugin. The node also stands in for part of Intersection Stitch.

Boolean Fracture (PCG)#

PCG_BooleanFracture · category PCG/modify · Houdini: Boolean Fracture (SOP)

Cuts the first input into separate pieces using the second input as the cutting geometry.

The cutter splits the geometry into one piece per connected component. Each piece gets a name (a prefix plus a number, or appended to the existing name), a piece attribute, interior and exterior face groups, interior and exterior seam edge groups, optional groups for pieces and faces inside a solid cutter, and interior and exterior normals.

When the cutter is treated as a Surface, each connected sheet is extruded along its average normal into a half-space and then used in the Boolean. The sheet must therefore pass entirely through the object and must not fold back along its average normal.

The backend is manifold3d, which requires closed manifold input. Point and vertex attributes are not carried over; primitive attributes and primitive groups are carried over from the source primitive.

Inputs

Outputs

Parameters

Pieces

Output Attributes

Output Groups

Boolean Settings

Compared with Houdini

With a surface cutter, a sheet that only cuts partway into the object still severs it here, because the sheet is extruded into a half-space. In Houdini it would not.

Bound (PCG)#

PCG_Bound · category PCG/modify · Houdini: Bound (SOP)

Builds a bounding box, bounding sphere or minimum-volume oriented box around the geometry.

Modes:

• Bounding Box: axis-aligned box. Fastest, but it becomes very loose when the object is tilted. A thin rod tilted 45 degrees has an axis-aligned box about 11 times the volume of its oriented box.
• Bounding Sphere: rotation invariant, cheap for coarse rejection. It starts from Ritter's algorithm, tightens it by moving toward the farthest point, and finally enlarges the radius so every point is covered.
• Oriented Bounding Box: minimum-volume OBB. The optimum always has one face flush with a face of the convex hull, so only hull face normals are tried, each followed by a 2D rotating-calipers fit. Only hull vertices take part, so a 50,000 point cloud may need only a few dozen.

The output carries detail attributes bound_center, bound_size, bound_rot (3x3 matrix, row-major) and bound_volume. bound_rot can be used to straighten the object or align something else to it: its rows are the box axes, so in Houdini's row-vector convention it maps box-local directions to world space, and Transform by Attribute (PCG) with Invert Transform (after moving bound_center to the origin) straightens the object.

Inputs

Outputs

Parameters

Carve (PCG)#

PCG_Carve · category PCG/modify · Houdini: Carve (SOP)

Cuts a curve at parametric positions or extracts points along it.

Keeps or extracts a portion of a curve between two U positions. NURBS and Bezier curves are cut by knot insertion, so the result is still a curve of the same type (subdividing into a polyline would lose that and block further degree changes or carving). Polygons and polylines are interpolated linearly by vertex parameter, and the end points land exactly on the requested positions.

In Cut mode, enabling only Second U keeps the part from 0 to Second U, because the disabled end is the curve end point.

Bidirectional U/V carving of surfaces is not implemented.

Inputs

Outputs

Parameters

Keep

Compared with Houdini

Carving of surfaces in U/V is not implemented, only curves.

Circle from Edges (PCG)#

PCG_CircleFromEdges · category PCG/modify · Houdini: Circle from Edges (SOP)

Rearranges each closed edge loop in a group into a perfect circle.

For every closed loop of the edge group, the center is the average of its points and the plane is defined by the loop's Newell normal. Point order along the loop is preserved. Open chains are skipped.

Even Spacing distributes the points at equal angles, choosing the phase that moves the points the least. Rotate then turns the whole circle about its normal.

Inputs

Outputs

Parameters

Circle Spline (PCG)#

PCG_CircleSpline · category PCG/modify · Houdini: Circle Spline (SOP)

Creates a smooth curve through the input points by blending circular arcs fitted to each three neighbouring points.

The arcs through each triple of adjacent points are blended pairwise with weight w = sin^2(pi*t/2). The curve passes through every point, and at each point its tangent and curvature equal those of the circle through the previous, current and next points (G2). If all points lie on one circle the result is that circle; where three points are collinear it is a straight line. Each segment gets Segment Divisions samples and the other numeric point attributes are interpolated linearly along the segment.

Helix fits a helix through each triple instead of a circle, with the axis chosen by Helix Type. A point string attribute splinetype (circle or helix) can override the type for the segment centered on that point. Adjust by Pseudo-Arclength keeps the point count but redistributes points evenly by arc length.

Inputs

Outputs

Parameters

Compared with Houdini

Houdini's Hybrid and Ellipse spline types are not implemented, because their definitions are not documented.

Clean (PCG)#

PCG_Clean · category PCG/modify · Houdini: Clean (SOP)

Repairs a polygon mesh by fusing points, removing degenerate and duplicate faces, fixing non-manifold edges and orientation, and dropping small pieces.

Runs a fixed sequence of steps: fuse points within the distance, remove degenerate primitives, remove duplicate faces (regardless of start vertex and winding), make manifold, consistently orient polygons, delete small pieces, remove unused points. The report output states how much each step changed.

Make Manifold keeps the two largest faces on an edge shared by more than two faces and splits bow-tie points.

Inputs

Outputs

Parameters

Compared with Houdini

Combines Clean with the repairs of PolyDoctor.

Clip (PCG)#

PCG_Clip · category PCG/modify · Houdini: Clip (SOP), Knife (SOP)

Cuts geometry with a plane and keeps the part below it, above it, or both.

The plane passes through origin + distance * direction and has direction as its normal. With Keep = All Primitives both halves are kept and simply separated along the plane; feed the result into Connectivity or a For-Each loop to process each half on its own.

Wherever the plane cuts an edge a new point is created, and every attribute on it is interpolated from the two end points: position, normals, UVs, point groups and edge groups all carry over.

Concave polygons are ear-clipped into triangles before cutting (Sutherland-Hodgman gives self-intersecting results on concave polygons), so cut concave faces come out as triangles. To get large faces back, follow with Divide using Remove Shared Edges. Primitives outside the group are passed through untouched.

Inputs

Outputs

Parameters

Origin

Output Groups

Compared with Houdini

The base normal (0,1,0) and the X-Y-Z rotation order for Transform orientation are not documented by SideFX; this node assumes them. Also covers the planar use of Knife.

Tips

• Use Keep = All Primitives followed by Connectivity to cut an object apart and process each part individually.

Convert (PCG)#

PCG_Convert · category PCG/modify · Houdini: Convert (SOP), Convert Volume (SOP)

Converts primitives between polygon, polyline, point, NURBS, Bezier and volume representations.

Changes the primitive type of the selected geometry. Splines are tessellated to polygons or polylines using the Divisions setting, and polygons can be fitted into NURBS or Bezier curves and surfaces. The volume targets rasterize the geometry into a signed-distance (SDF) or fog volume.

NURBS support is limited to uniform clamped knot vectors; arbitrary non-uniform knots are not supported, because attributes here are fixed-size arrays and a per-primitive variable-length knot vector does not fit. Uniform clamped covers everything the Houdini Convert SOP produces.

Inputs

Outputs

Parameters

Divisions

NURBS

Volume

Compared with Houdini

NURBS are limited to uniform clamped knots. The volume options approximate parts of Convert VDB and VDB from Polygons.

Convex Decompose (PCG)#

PCG_ConvexDecompose · category PCG/modify · Houdini: Convex Decomposition (SOP)

Splits a concave solid into a set of convex pieces (approximate convex decomposition).

A convex hull only gives the outer skin of a shape, and for an L, a bowl or a chair that smooths away exactly what makes the shape. Physics engines handle convex bodies fast and concave ones slowly or not at all, hence the decomposition.

Concavity is measured by volume: 1 - solid volume / hull volume. It is exactly 0 for a convex piece and tells how much air the hull would add. (Defining it as the distance from the most concave point to the hull would let a negligible spike make the whole object look very concave.)

Each split minimizes the sum of the two child hull volumes. Candidates are three axes times Split Candidates minus 1 positions; each is really cut and both hulls computed. By default the axes are those of the oriented bounding box, not the world axes; world axes cut a tilted L badly, and the OBB axes also make the result rotation covariant.

Max Pieces is a global budget, not a depth limit. A heap ordered by absolute concave volume always splits the worst piece first. After each cut the pieces are split into connected components, so a cut across the opening of a U does not leave one piece whose hull fills the gap.

Output modes: Convex Hulls replaces each piece by its hull (what collision proxies need; total volume is at least the original). Exact Pieces keeps the cut solids, whose total volume equals the original exactly.

Max Hull Points caps the vertex count of each hull for engine collision. 32 points (at most 60 triangles) usually stays within a few centimetres of a 2 m rock.

Inputs

Outputs

Parameters

Search

Convex Hull (PCG)#

PCG_ConvexHull · category PCG/modify

Builds the 3D convex hull of the input points.

Useful for collision proxies, for wrapping a point cloud into a solid, for the exact answer to how much space a set of points occupies, and as the basis of the oriented mode of Bound.

The algorithm is quickhull: each round takes the farthest outside point as a new vertex, deletes the faces visible from it and joins the horizon to it with new faces. Visible faces are found by flood-filling over adjacency from the starting face, not by scanning all faces, because a full scan can report a nearly coplanar far face as visible because of floating point noise and break the horizon into two loops.

Degenerate input does not raise an error but drops a dimension: coplanar points give a polygon, collinear points a line segment, coincident points a single point.

Inputs

Outputs

Parameters

Compared with Houdini

Degenerate input (coplanar, collinear or coincident points) produces a polygon, line or point, where Houdini returns empty geometry.

Crease (PCG)#

PCG_Crease · category PCG/modify · Houdini: Crease (SOP)

Writes a fractional crease weight onto edges for later subdivision.

Writes the weight into the vertex attribute creaseweight (or the attribute you name). For every selected edge, the half-edge start vertex on both sides of the edge is written. Subdivide reads this attribute for semi-sharp creases: with a weight of 1 or more the edge is sharp for that round, values between 0 and 1 blend, and the weight decreases by 1 each subdivision round.

Inputs

Outputs

Parameters

Curve Fillet (PCG)#

PCG_CurveFillet · category PCG/modify

Rounds polyline corners with circular arcs.

Replaces the selected corners of polylines with circular arcs of the given radius, tangent to both neighbouring segments. With Limit Radius the arc shrinks where a segment is too short to fit it, so neighbouring fillets never overlap.

Closed polylines and polygons have every point treated as a corner; open curves keep their end points. Nearly straight corners are left alone. The arc points copy the corner's point attributes.

Inputs

Outputs

Parameters

Curve Intersect (PCG)#

PCG_CurveIntersect · category PCG/modify · Houdini: Curve Intersect (SOP)

Finds intersections between curves and outputs points, split curves, or Houdini-style cut and extract results.

Intersects curves pairwise. With Plane set to XZ, XY or YZ the test is made on the projection onto that plane (a road network is intersected from above); 3D requires two segments to actually come within Tolerance of each other.

Output modes:

• Intersection Points: only the intersection points, carrying prim_a, prim_b, u_a and u_b (the two primitives and their curve parameters).
• Split Curves: cuts the curves at the intersections, with the intersection points shared, so the result is a connected network that Find Shortest Path can walk directly. The intersection points go into Point Group.
• Cut and Extract follow the Houdini Method semantics: intersect between the left curves (selected by Group) and the right curves (Cutter Group; they come from the second input cutter, or from the main geometry when it is not connected). Cut cuts both sides into segments and keeps the odd or even numbered ones as chosen; Extract outputs the intersection points (Affect chooses left, right or both, and Keep Original keeps the curves).

Inputs

Outputs

Parameters

Delete (PCG)#

PCG_Delete · category PCG/modify · Houdini: Delete (SOP), Point Delete (COP)

Deletes points, primitives or edges chosen by group, number, bounding volume, normal, degeneracy, random chance or an expression.

Where Blast deletes by group, Delete covers conditions a group pattern cannot express: every Nth element, everything outside a box, faces pointing away from a direction.

The filters combine as an intersection: group AND number AND bounding volume AND normal AND expression, and a disabled filter selects everything. So first pick an area with the group, then delete every third element in it; turning on another filter narrows the selection and never widens it.

With no filter enabled and an empty group the node does nothing, since treating an empty group as everything would wipe the whole geometry. When Entity is Edges, only the group is honoured and the filter sections below do not apply; the end points of the selected edges are deleted.

Inputs

Outputs

Parameters

Number › Number

Bounding Volume › Bounding Volume

Normal › Normal

Degenerate › Degenerate

Random › Random

Expression › Expression

Compared with Houdini

Intersection of all filters corresponds to the Houdini Delete SOP's behaviour of combining its selection tabs.

Dissolve (PCG)#

PCG_Dissolve · category PCG/modify · Houdini: Dissolve (SOP)

Removes selected edges and merges the faces on either side of them into one.

This is the same machinery as Remove Shared Edges in Divide, with a different granularity: Divide works on a primitive group and merges all interior edges between the selected faces, while Dissolve works on an edge group and merges only the edges you picked.

Connected selected edges are merged into one block in a single step instead of one by one, because merging one by one needs a topology rebuild each time and intermediate states may not be valid polygons. A block that does not yield a single boundary loop (it has holes) is left as it is, since a primitive can store only one vertex loop; the Bridge option decides what happens to such blocks.

Remove Inline Points is on by default and is the easily overlooked half of Dissolve: after merging, the end points of a dissolved edge typically have only two edges left and are collinear, so the face count drops while the vertex count does not. The test uses an angle rather than exact collinearity, as computed edges are rarely exactly collinear.

Boundary edges, which have only one face, are skipped, and their number is written to the detail attribute dissolve_skipped.

Inputs

Outputs

Parameters

Compared with Houdini

The Create Disjoint Polygons bridge option is not implemented.

Divide (PCG)#

PCG_Divide · category PCG/modify · Houdini: Divide (SOP)

Triangulates or splits faces into convex polygons, cuts them into bricks, merges shared edges, or computes the dual.

Triangulation is done carefully here: convex faces use a fan (linear time, and most faces are convex), concave faces use ear clipping. The Convert node's Triangles option is a plain fan, which gives triangles that reach outside the shape on concave n-gons, and concave n-gons are common in the output of Boolean, PolyBevel and Carve. Use this node when correct triangles are needed.

With Maximum Edges above 3, faces are first ear-clipped and then greedily merged back into convex polygons, only across diagonals and only when the result is still convex, so the covered area is unchanged.

Bricker Polygons cuts faces with three sets of parallel planes spaced by Brick Size, handy for floors and window panes of buildings. Smooth Polygons is not implemented (use Subdivide).

Inputs

Outputs

Parameters

Convex Polygons

Triangulate Non-Planar

Bricker Polygons

Remove Shared Edges

Compute Dual

Compared with Houdini

Smooth Polygons is not implemented; use the Subdivide node.

Edge Collapse (PCG)#

PCG_EdgeCollapse · category PCG/modify · Houdini: Edge Collapse (SOP)

Collapses each connected run of selected edges into a single point at the run's center.

Edges in the group that are connected in a chain are collapsed into one point placed at the center of the chain's points. Afterwards duplicate corners and faces that can no longer stand are removed.

Inputs

Outputs

Parameters

Edge Divide (PCG)#

PCG_EdgeDivide · category PCG/modify · Houdini: Edge Divide (SOP)

Inserts points on selected edges and optionally connects them to split the faces.

Inserting points and connecting them are two separate steps. Insertion is safe for any face; connecting has a unique answer only when exactly two edges of a face are cut, since otherwise there is no non-arbitrary choice for where a point should connect.

• Face with 0 edges cut: unchanged.
• Face with 2 edges cut and Connect on: split into Cuts + 1 pieces.
• Any other case: points are inserted only and the face becomes an n-gon with more edges.

Cut positions can be given explicitly (0.2 0.5 0.9); otherwise the edge is divided evenly according to Cuts.

Inputs

Outputs

Parameters

Compared with Houdini

For faces with three or more cut edges, Houdini fans the new points to the face center, which adds a point not on any edge. This node only inserts the points; use Divide afterwards to decide how to cut.

Edge Equalize (PCG)#

PCG_EdgeEqualize · category PCG/modify · Houdini: Edge Equalize (SOP)

Evens out edge lengths along edge chains, either by redistributing points along the polyline or by Houdini's target-length methods.

Selected edges are strung into chains. With Redistribute Along Curve (this plugin's method) the points are redistributed into equal segments along the original polyline, so the shape and total length stay the same. Open chains keep their end points; for pure closed loops the phase that moves the points least is chosen; loops passing through a fork point keep the fork point pinned.

The other three methods follow Houdini: the target edge length is the average, longest or shortest of the selected edges, each edge is scaled about its midpoint, and shared points are averaged and iterated to convergence. The shape and the total length change.

Inputs

Outputs

Parameters

Edge Straighten (PCG)#

PCG_EdgeStraighten · category PCG/modify · Houdini: Edge Straighten (SOP)

Pulls each open chain of selected edges into a straight line, keeping its end points fixed.

Each open chain in the edge group is straightened between its two end points. Closed loops are skipped, and the report states how many.

Inputs

Outputs

Parameters

Ends (PCG)#

PCG_Ends · category PCG/modify · Houdini: Ends (SOP)

Closes, opens, unrolls or rolls curves.

The prim_closed flag decides whether there is an edge between the last and first point. Many nodes (Resample, Carve, Sweep, PolyExpand2D) treat open and closed curves differently, and the upstream flag is often not what you need.

The four operations differ in whether the geometry changes:

• Close Straight: flips the flag, adds one closing edge, so the shape changes.
• Open: flips the flag, removes one edge, so the shape changes.
• Unroll with Shared Points: closed to open, hanging the first point again on the end. The edge count and shape are unchanged, the only operation that merely changes the representation.
• Roll: the inverse of unroll, turning an open curve with coinciding ends into a closed one with the duplicate point removed.

Unroll is the most common: a closed loop has no starting point, so a resampler does not know where to start. After unrolling it is an ordinary open curve that looks identical; roll it back when done. Unroll followed by roll is an exact topological identity.

Primitives with two points are not closed, since that would create two coincident edges (a zero-area degenerate face that looks the same as before but breaks normals and area later). They are silently skipped.

Inputs

Outputs

Parameters

Exploded View (PCG)#

PCG_ExplodedView · category PCG/modify · Houdini: Exploded View (SOP)

Moves fracture pieces apart from each other so cuts can be inspected.

The output of Voronoi Fracture, Voronoi Cluster and Convex Decompose fits together seamlessly, so it looks as if nothing was cut. This node pushes the pieces apart.

Every piece undergoes a rigid motion: each piece is translated individually, so each piece's volume is unchanged. (Scaling the whole geometry about the center separates the pieces but scales each by the same factor, and its volume by the cube.)

The piece center is the area-weighted centroid, not the mean of the points. A mean would be biased by mesh density: a Voronoi cut face is one n-gon with few points, while the outer shell inherits the original tessellation with many.

Pieces come from a primitive attribute (name, piece or cluster, as written by the upstream nodes) or from connected components.

Inputs

Outputs

Parameters

Extract Transform (PCG)#

PCG_ExtractTransform · category PCG/modify · Houdini: Extract Transform (SOP)

Computes the best-fit transform from a reference geometry to a deformed or moved copy of it.

The two inputs must be the same geometry before and after (point numbers correspond one to one). The node solves for the best rigid (Kabsch), similarity (Umeyama, adds uniform scale), non-uniform scale or full affine transform.

The point output is an instance point (P, orient, pscale; scale for non-uniform; transform for affine or matrix output). Feeding it to Copy to Points with the reference as the source places the copy on the target. The geo output is the reference transformed directly. The report contains the residual RMS.

With Use Piece Attribute, the geometry is split by a primitive or point attribute and each piece gets its own transform and its own output point (carrying the attribute); the point is placed at the transformed piece center and the pivot is the weighted center of the reference piece. Pieces with too few points for the fit (fewer than 3, or 4 for affine) get a translation only. Without it, one transform is fitted to the whole geometry.

Inputs

Outputs

Parameters

Compared with Houdini

The weight attribute does not exist on the Houdini node; it is an addition of this plugin.

Facet (PCG)#

PCG_Facet · category PCG/modify · Houdini: Facet (SOP)

Runs a fixed chain of topology cleanup and hard-edge options: unique points, consolidate, orient, cusp, inline and degenerate removal, normals.

The enabled steps always run in Houdini's order, each consuming the result of the previous one:

unique points -> consolidate -> orient -> cusp -> remove inline -> remove degenerate -> normals

The easy trap is that orient has to precede cusp. With inconsistent winding, adjacent face normals point opposite ways, the angle between them is always 180 degrees, and the whole geometry would be split into hard edges.

Cusp is not the same as the vertex mode of a Normal node. Normal only stores one normal per corner and leaves the geometry alone; Facet's cusp actually splits the points, so any point normal computed afterwards is hard. Use Facet for engine export, UV seams, or when downstream nodes must see the hard edges.

The group is a primitive group; primitives outside it are left exactly as they are (no winding change, no point splitting, no corner removal).

Inputs

Outputs

Parameters

Fracture Detail (PCG)#

PCG_FractureDetail · category PCG/modify

Adds noise to the cut (interior) faces of fracture pieces while keeping the pieces fitting together.

Cut faces from a Voronoi fracture are perfectly flat and look fake. The difficulty is that the pieces must still fit back into the original shape and the outer silhouette must not change.

The displacement is a pure function of world position, not a push along normals. Pieces A and B share a wall, each storing its own copy of the points at the same position but with opposite normals. A scalar pushed along normals would move the two copies in opposite directions and open a gap or interpenetrate. A vector noise depending only on world position gives both copies bit-identical displacement, so the wall stays shared and merely bends. The sum of all piece volumes is therefore unchanged.

The falloff is a pure function too. The rim where the cut face meets the original surface is pinned so that the outer silhouette does not change. Falloff uses the Euclidean distance to the global point cloud of rim points rather than a graph distance along the surface, because graph distances can differ between the two copies of a shared wall and would tear it.

Divisions first applies linear subdivision, since a cut face is typically one large n-gon and pushing its few points only tilts the plane. The whole piece is subdivided, since subdividing only the cut face would leave T-vertices on the border.

Triangulate Interior (on by default) triangulates the cut faces by picking the fan apex as the vertex with the lexicographically smallest coordinates, so that both sides of a shared wall pick the same diagonals. Without this, a displaced non-planar wall can open a thin crack.

Beveling is not part of this node: the cut faces are already a primitive group, so connect PolyBevel.

Inputs

Outputs

Parameters

Noise

Fuse (PCG)#

PCG_Fuse · category PCG/modify · Houdini: Fuse (SOP)

Snaps nearby points together (to each other, to a grid, or to a target) and optionally welds them into single points.

Three stages: Snap decides which points count as the same and where they go, Fuse decides whether the topology is actually welded, and Output manages groups and normals.

Near-point snapping does a real radius search (uniform grid hashing) and takes the transitive closure of the pairs, so chains of close points end up in one cluster regardless of grid cell borders, unlike a quantizing fuse.

When the target input is connected, points in the group snap to points on the target. The two geometries are not merged; the target only provides the places to snap to. With Modify Target the roles swap and the modified target is output.

The position attribute can be a different 3-component attribute (for example a rest position), so that proximity is judged in another space. This is useful for cleanup after deformation.

Inputs

Outputs

Parameters

Snap

Snap › Target

Snap

Snap › Snap Distance

Snap › Radius

Snap › Match Attribute

Snap › Grid

Fuse › Fuse

Output Attributes and Groups › Output

Intersection Analysis (PCG)#

PCG_IntersectionAnalysis · category PCG/modify · Houdini: Intersection Analysis (SOP)

Places a point wherever triangles or polylines pass through each other and records their sources.

With only the first input connected, it finds self-intersections; with both inputs it finds intersections between them. Each intersection gets a point carrying, for the two sources, the input number, primitive number and primitive UVW, each stored twice: [primitive containing the edge, primitive of the triangle that is pierced]. An attribute name left empty is not written. The input does not need to be a closed manifold.

Inputs

Outputs

Parameters

Output Attributes

Join (PCG)#

PCG_Join · category PCG/modify · Houdini: Join (SOP)

Connects the selected polylines in order into one polyline, bridging gaps with straight segments.

The order is primitive order. The typical use is to join separately made path pieces into one complete path, where the end points are not supposed to coincide and the connecting segments are exactly what you want. This bridging is the one difference from PolyPath.

Reverse To Fit (on by default): before each primitive is appended, the end nearer the current tail is placed first. Houdini's Join does not do this, and without it a slightly inconsistent direction among the input primitives yields a zigzag that doubles back. That happens almost inevitably with Clip or Boolean output, as those do not guarantee consistent segment orientation. With it off, the result is strictly tail-to-head.

Tolerance is not a weld radius but a measure of how near counts as already connected: a gap smaller than it is treated as the same point (no bridging segment, no zero-length edge), a larger gap gets a connecting segment.

Loop joins the last segment back to the first start and outputs a closed primitive. Partition Attribute joins each group of a primitive attribute separately (for example one path per name).

Primitive attributes are taken from the first primitive of the chain, as in Houdini. Vertex attributes follow the corners, so when a line is reversed its UVs and widths are reversed with it; otherwise texture flow would flip at the seam.

Inputs

Outputs

Parameters

Loop Cut (PCG)#

PCG_LoopCut · category PCG/modify

Inserts a complete edge loop through quads, starting from seed edges.

Works like the loop mode of PolySplit (Loop Cut or Insert Edge Loop in other packages). From a seed edge it enters the neighbouring quad, takes the opposite edge (two steps around the vertex loop), then crosses to the next quad, until it returns to the start or hits a boundary or a non-quad. The collected edges are cut like Edge Divide with connect on.

A non-quad ends the loop: a triangle has no opposite edge, and a pentagon has two, so the loop is genuinely broken there (Blender and Maya behave the same).

One seed edge is enough; giving several on the same loop does not cut it twice.

Inputs

Outputs

Parameters

Match Axis (PCG)#

PCG_MatchAxis · category PCG/modify · Houdini: Match Axis (SOP)

Rotates geometry by the smallest rotation that takes one axis direction onto another.

Rotates From Axis onto To Axis with the minimal rotation, about the origin, the centroid or the bounding box center. If Up From and Up To are both non-zero, a further rotation about the main axis then also aligns the up vectors. The vector attributes N, up, v and orient are rotated along with the points.

Inputs

Outputs

Parameters

Match Size (PCG)#

PCG_MatchSize · category PCG/modify · Houdini: Match Size (SOP)

Moves and scales geometry to fit a reference box, and can stash the transform so it can be undone later.

The real use is less resizing than establishing a recoverable canonical space: match any model to a unit box, work in that space (cut, scatter, compute UVs), then send it back with the stashed transform. The Stash and Restore fields are as important as the alignment.

If the second input is connected, the geometry is aligned to its bounding box. Otherwise (or with Location and Size) the target position and size parameters define the box.

When Restore Attribute names a detail attribute that actually exists on the geometry, the node only restores: it inverts the stored 4x4 matrix and applies it, ignoring all other parameters. As in Houdini, restoring and matching are two separate, mutually exclusive operations.

Inputs

Outputs

Parameters

Bounds Group

Justify To

Scale to Fit

Transform Attribute

Merge (PCG)#

PCG_Merge · category PCG/modify · Houdini: Merge (SOP), Point Merge (COP)

Combines up to six geometries into one.

Concatenates the points and primitives of all connected inputs. Attributes and groups are the union across the inputs; where an input lacks an attribute its elements get zeros, and where it lacks a group its elements are simply not in the group. Empty inputs are ignored.

Inputs

Outputs

Mirror (PCG)#

PCG_Mirror · category PCG/modify · Houdini: Mirror (SOP)

Mirrors geometry about a plane, optionally keeping the original and welding the seam.

Three details matter and are handled here:

1. Mirroring flips orientation, so the winding is reversed. A reflection has determinant -1; reflecting only positions leaves the mirrored half with inward normals (black in renders, culled, and negative volume). Reverse Normals does this.
2. Vector attributes are reflected, not copied. Directions such as N, v, up and tangents must be reflected, while Cd and uv are copied as they are. There is no type system to tell them apart, so a name list is used and can be extended.
3. In append mode the seam is welded. Without welding, the points sitting on the plane exist twice and the seam is a ring of doubled boundary edges, so topology is not closed and nodes that require closed meshes fail. Points close to the plane are first projected exactly onto it (floating point puts a point meant to be at x=0 at +-1e-8), then welded within Snap Tolerance.

Inputs

Outputs

Parameters

Peak (PCG)#

PCG_Peak · category PCG/modify · Houdini: Peak (SOP)

Moves points along their normals by a distance.

Pushing points by d along the point normal is not the same as growing the surface by d. A cube corner has normal (1,1,1)/sqrt(3); moving it by d shifts that corner only 0.577d along each face normal. Flat faces are no longer flat, the offset does not match the number entered, and a cube does not stay a cube. Houdini's Peak behaves the same way.

Miter Corners multiplies the displacement by 1 / (n_point . n_face), using the smallest dot product over the adjacent faces. This is a miter: the corner lands at the intersection of the offset adjacent faces. A cube corner gets sqrt(3), the cube stays a cube, and its edge length grows by exactly 2d. At nearly tangent folds the factor explodes, so Max Miter caps it.

Existing normals in N are used (upstream may have set a cusp angle or perturbed them); if there are none, they are computed but not written back. Distance Attribute gives each point its own factor, to combine with Attribute Fade or Attribute Noise.

Inputs

Outputs

Parameters

Point Jitter (PCG)#

PCG_PointJitter · category PCG/modify · Houdini: Point Jitter (SOP)

Adds random displacement to points.

Each point moves in a random direction by at most Scale (further multiplied by the mask, pscale and the per-axis scales).

The random stream is keyed by the ID attribute when one is given, not by point number. If points are deleted upstream, sorted or fused, point numbers shift and a jitter keyed by number would change everywhere.

The displacement is uniform inside a sphere, not inside a cube. Taking three independent values in [-1,1] would make diagonals 1.73 times longer than the axes, a visible directionality on grid-like input. If you want directionality, use Axis Scales.

Inputs

Outputs

Parameters

Point Split (PCG)#

PCG_PointSplit · category PCG/modify · Houdini: Point Split (SOP), Split Points (SOP)

Splits points whose vertices carry different values of a vertex attribute into separate points.

When several vertices share one point but disagree on a vertex attribute (a UV seam, a hard edge in N), the point is duplicated so that each distinct value gets its own point. Values are compared with a chained tolerance rather than by bucketing, so values that are within tolerance of each other through a chain of neighbours end up on the same point.

With an empty attribute name every vertex becomes its own point. With Promote on, the vertex attribute is also written as a point attribute of the same name on the new points.

Inputs

Outputs

Parameters

Compared with Houdini

Corresponds to Houdini's Split Points / Point Split behaviour for vertex attributes.

Poly Bridge (PCG)#

PCG_PolyBridge · category PCG/modify · Houdini: Poly Bridge (SOP)

Builds a surface of polygons between two loops of edges, such as a tunnel or handle.

Source and Destination are either primitive groups or point groups. For primitives that are faces, their outer boundary is used (and the faces are deleted if Remove Source and Destination Faces is on); for open curves the curve itself is used. Point groups describe the boundary of a hole.

If both loops have the same number of points the bridge is made of quads; otherwise triangles are zipped by arc length. The start points are aligned automatically and Twist shifts the pairing by a number of points. The bridge has Divisions segments, interpolated linearly or with Hermite curves that leave along the cap normals (handle versus tunnel direction is detected automatically).

Face orientation is made consistent with neighbouring faces, so the result stays watertight after punching a tunnel. New polygons go to the output group.

Inputs

Outputs

Parameters

PolyBevel (PCG)#

PCG_PolyBevel · category PCG/modify · Houdini: PolyBevel (SOP)

Bevels edges of polygon geometry with an optional rounded, chamfered, solid or crease profile.

Every polygon adjacent to a beveled edge is shrunk away from that edge, then the gaps are bridged: faces become inset polygons, edges become bridge strips, and points become n-gons around the original point. New points are moved off the original edge into their faces, so the result is a true edge bevel and not a vertex cut.

The selected edges are interior manifold edges whose two sides are both selected. Group Type decides how group is interpreted: an edge group directly, or primitives or points from which the edges are derived. Ignore Flat Edges skips edges whose two faces meet at less than Maximum Normal Angle.

Output groups mark the generated fillet polygons and, optionally, the edges between the bevel faces and the shrunk faces.

Attributes and groups are carried over: new points copy the point attributes and point groups of the original point they come from, every new face takes the primitive attributes and groups of the face it was cut from (fillet strips from one adjacent face, corner patches from one face around the corner), and vertex attributes such as uv are copied from the corner of that face at the same original point. Detail attributes are kept.

Inputs

Outputs

Parameters

Fillet

Output Groups

Compared with Houdini

Follows Houdini's PolyBevel, including the None shape, Ignore Flat Edges, Scale by Attribute (default pscale), Convexity and Offset Group. Distance limiting is the simplified half-shortest-neighbour-edge rule, not the full Collisions and Limits options.

PolyDoctor (PCG)#

PCG_PolyDoctor · category PCG/modify · Houdini: PolyDoctor (SOP)

Detects and optionally repairs common polygon problems, writing validity flags.

Each check has its own mode. Ignore skips the check, Mark only flags the problem, Repair fixes it and flags what was changed. Checks cover ill-formed polygons, polygons with five or more edges, non-convex polygons, overlapping polygons (optionally in pairs), polygons with locally small areas, non-uniform polygons, globally and locally small edges, disconnected points and non-manifold points.

Polygons that fail a check get valid_poly = 0 and points get valid_pt = 0; polygons or points that were fixed get repaired_poly = 1 or repaired_pt = 1. Attribute names are configurable and a group for each attribute can be created. Repairs run for at most Max Passes rounds.

Self-Intersecting Polygons (mark only) flags polygons that pass through other polygons of the same mesh, found with Intersection Analysis on the repaired result; faces that share a point are not tested against each other.

Inputs

Outputs

Parameters

Primitives

Edges & Points

Topology

Attributes

Compared with Houdini

Partial implementation of PolyDoctor. Non-Uniform Polygons can only be marked. For general cleanup, PCG_Clean remains available.

PolyExpand2D (PCG)#

PCG_PolyExpand2D · category PCG/modify · Houdini: PolyExpand2D (SOP)

Offsets a planar curve network inward and outward by a constant distance.

Produces offset curves (or the surface between input and offset) for a planar network of curves. Rather than just pushing each edge, the node builds mitered offsets that may self-intersect and then cuts away every part whose midpoint is closer than Offset to the input. What remains matches a straight-skeleton offset, with no event queue and therefore no degenerate-event ordering problems.

Inside and outside come from the faces of the input itself: the input is treated as a planar graph (welded, split at intersections, traversed by angle). Bounded faces offset inward give inside; the unbounded face offset inward expands outward and gives outside. A tree-shaped network has no bounded face, so it only has an outside loop around the whole network.

Open curve ends get a square cap extended by Offset along the tangent. A flat cap would lie at distance 0 and be trimmed away, breaking the loop. With Split Offset Curves to Omit End Caps the three cap segments are removed and two lines along the sides remain.

Inputs

Outputs

Parameters

Local Attributes

Advanced

Compared with Houdini

Does not implement a straight skeleton with an event queue. It trims a self-intersecting mitered offset by distance to the input, which gives the straight-skeleton offset without degenerate-event ordering problems.

PolyExtrude (PCG)#

PCG_PolyExtrude · category PCG/modify · Houdini: PolyExtrude (SOP)

Extrudes polygons along their normals, a fixed direction or a spine curve, with inset, twist and divisions.

Extrudes the selected primitives and creates front, back and side polygons. Divide Into decides what counts as one region: Connected Components extrudes touching selected faces together, so side walls appear only where the two sides of an edge belong to different regions; Individual Elements extrudes every face on its own.

Inset uses angle-bisector miters scaled by 1/sin(half angle), so every edge moves in by the same perpendicular distance. Limit Insetting clamps the inset before edges flip.

If the spine input is connected and External Spine is on, the faces are swept along the spine curve using a rotation-minimising frame, initialised per region from the face's own axis, so there is no spurious twist between face orientation and the spine's normal plane. Distance and Twist are then ignored; the spine decides the length.

Groups: front, back and side polygons can be written to groups. Upstream groups are inherited by the front and back faces only, not by the side walls, which are new geometry.

Inputs

Outputs

Parameters

Extrusion

Extrusion › Direction

Extrusion

Extrusion › Spine

Extrusion › Front Transform

Output Geometry and Groups › Output

Output Geometry and Groups › Insetting

Output Geometry and Groups › Normals

Local Control › Local Control

UVs › Texture

PolyFill (PCG)#

PCG_PolyFill · category PCG/modify · Houdini: PolyFill (SOP)

Closes open boundary loops with new polygons.

Clip, Blast and Delete leave openings, while volume computation, booleans and Voronoi fracture all want closed geometry. PolyFill finds the boundary loops of the input and caps each one.

The winding of the new face is the reverse of the boundary half-edges, so the cap normal agrees with the neighbouring faces. Fill modes: Single Polygon covers the hole with one n-gon (no points added; best for planar holes), Triangle Fan adds a point at the hole centre and fans triangles (use it for non-planar holes, where an n-gon would twist), Triangles ear-clips without adding points and handles concave holes, Quadrilateral Fan adds a centre point and makes one quad per two boundary edges (an odd count leaves one triangle), Quadrilaterals folds the loop into two chains and joins them quad by quad without new points (like a single polygon it suits convex, roughly flat holes), and Quadrilateral Grid treats the loop as the four sides of a patch and fills it with a Coons-interpolated quad grid. If the edge count is odd, the grid mode falls back to Quadrilaterals.

Inputs

Outputs

Parameters

PolyPath (PCG)#

PCG_PolyPath · category PCG/modify · Houdini: PolyPath (SOP)

Joins polylines whose end points touch into the longest possible curves, without creating any edges.

Resample, Carve, Sweep and PolyExpand2D all work per primitive, so a curve has to be one primitive for them to know what "along the curve" means. Upstream nodes often deliver many fragments (a Clip, or Convert Line output, or several merged lines whose ends coincide but are different points). PolyPath chains them into longer primitives.

It never creates an edge: only end points that already coincide are connected, the shape is unchanged, and only the assignment of points to primitives changes. (Join, in contrast, forces connections and adds straight segments where ends do not meet.)

Each input polyline is an atomic unit and only its two end points take part in connections. A long polyline that another line happens to cross in the middle is therefore kept whole, which differs from Houdini's PolyPath. Polylines that are already broken have to be split with Dissolve or Blast first.

Faces and closed primitives are not touched; they pass through unchanged. When two end points are within Point Tolerance but not the same point, the one that comes first is kept and positions are not averaged, so the geometry does not move. Use Fuse first if you want both to move.

Inputs

Outputs

Parameters

Compared with Houdini

Houdini's PolyPath breaks inputs into edges and re-chains them, which splits a long polyline where another line happens to cross it. This node treats each polyline as a unit and only connects end points.

PolyReduce (PCG)#

PCG_PolyReduce · category PCG/modify · Houdini: PolyReduce (SOP)

Reduces triangle or point count with quadric error edge collapse.

Implements Garland-Heckbert quadric error metric (QEM) edge collapse. Each point carries a 4x4 quadric (the area-weighted sum of squared distances to its planes); collapsing an edge adds the two quadrics, so error accumulates over successive collapses and the node does not keep eating the same spot.

The input is triangulated first and the output is always triangles (there is no Preserve Quads). Boundaries is usually the most important value: without it QEM happily eats away the border of flat meshes. Crease edges work through the same mechanism with their own weight. Soft Points add a cost for moving away from the original position, and Hard Edges lock both of their end points.

With Preserve UVs only half-edge collapses are performed, points on UV seams and hard edges are locked, and vertex attributes are rewritten along the way, so an LOD shares the textures of the original. This node is the only greedy serial algorithm in the plugin; reduction cannot be computed as one batch.

Inputs

Outputs

Parameters

Limit Using Normal Deviation

Output Geometry

Stiffen

Preserve Features

Compared with Houdini

The output is always triangles; Houdini's Preserve Quads is not implemented.

PolySpline (PCG)#

PCG_PolySpline · category PCG/modify · Houdini: PolySpline (SOP)

Converts polylines into smooth spline curves sampled as polylines.

Each selected curve is interpreted as control points of the chosen Spline Type and sampled with Sample Divisions samples per span. Catmull-Rom passes through the points, with an Alpha that selects uniform, centripetal or chordal parametrisation; BSpline approximates (C2, does not pass through interior points); Interpolating (C2) passes through the points and is C2, solving a tridiagonal system for the control points; Bezier and Degree 2 Bezier take the points as control points, three (or two) per segment with shared end points; Cardinal passes through the points with tangents scaled by CV Tension; Linear gives straight segments.

Open curves pass through both end points. Numeric point attributes are interpolated with the same weights as P.

A Division Method other than Standard resamples the result afterwards with equal arc length or equal distance along one axis.

Inputs

Outputs

Parameters