Deform#

Nodes that move points without changing topology.

16 nodes.

Back to the reference index

Contents#

• Blend Shapes (PCG) — Blends point attributes between a base shape and up to four same-topology target shapes.
• Bulge (PCG) — Pushes points outward inside the influence of a magnet geometry to create a bulge.
• DeltaMush (PCG) — Smooths a deformed mesh while restoring the fine detail of its rest shape.
• Displace from Map (PCG) — Displaces points along their normal or a fixed vector using values sampled from an image at the point UVs.
• Fractal (PCG) — Roughens a surface by midpoint displacement.
• Lattice (PCG) — Deforms geometry with a lattice using free-form deformation.
• Lattice From Bound (PCG) — Creates a grid of control points around the bounding box of the input, for use with Lattice.
• Magnet (PCG) — Transforms points inside the influence of a magnet geometry, weighted by falloff.
• Path Deform (PCG) — Bends geometry along a curve.
• Point Deform (PCG) — Deforms high-resolution geometry using the motion of a low-resolution point cloud.
• Soft Peak (PCG) — Pushes a group of points along their normals, with nearby points following by a soft falloff.
• Soft Transform (PCG) — Transforms a group of points and lets nearby points follow with a soft falloff.
• Spherify (PCG) — Pushes the selected points onto a sphere.
• Topo Transfer (PCG) — Fits the wiring of one mesh onto the shape of another.
• Transform Pieces (PCG) — Moves pieces of a fragmented geometry onto the matching points of a template, such as RBD output or a skeleton.
• Twist / Bend / Taper (PCG) — Twists, bends, tapers, squashes or shears points along a chosen axis.

Nodes#

Blend Shapes (PCG)#

PCG_BlendShapes · category PCG/deform · Houdini: Blend Shapes (SOP)

Blends point attributes between a base shape and up to four same-topology target shapes.

Mixes the listed point attributes (default P N) of geometries that share the same topology. Additive computes base + sum(w_i * (target_i - base)), so weights may go outside 0..1 and several shapes can be stacked. Sequential uses one Blend value that travels base, target 1, target 2, and so on; 1.5 is halfway between target 1 and target 2. Slots are counted by number, so an unconnected slot holds the previous shape.

If N is blended it is renormalized afterwards. Points can be matched by point number or by an id point attribute, which allows shapes whose point order has been shuffled.

Inputs

Outputs

Parameters

Bulge (PCG)#

PCG_Bulge · category PCG/deform · Houdini: Bulge (SOP)

Pushes points outward inside the influence of a magnet geometry to create a bulge.

The second input acts as a magnet. With Points magnets every magnet point has a spherical influence of radius pscale * Radius; with Surface magnets the influence is based on the distance to the magnet surface. Points of the first input inside the influence are displaced by Magnitude * weight, where the weight comes from the falloff ramp. The displacement runs along the point normal or directly away from the magnet.

Normals are recomputed afterwards when the input has N. The falloff weight can optionally be written to a point attribute.

Inputs

Outputs

Parameters

Influence

DeltaMush (PCG)#

PCG_DeltaMush · category PCG/deform · Houdini: DeltaMush (SOP)

Smooths a deformed mesh while restoring the fine detail of its rest shape.

Takes the deformed geometry and a rest version with the same topology. Both are smoothed; the detail lost by smoothing the rest shape is recorded in a local frame on the smoothed surface and reapplied to the smoothed deformed shape. Local damage from the deformation is smoothed away, while the detail returns as it looked in the rest pose. For rigid motion of the whole mesh the result equals the deformed input exactly.

A point attribute can be used as a mask to control how much of the correction each point receives.

Inputs

Outputs

Parameters

Displace from Map (PCG)#

PCG_DisplaceFromMap · category PCG/deform

Displaces points along their normal or a fixed vector using values sampled from an image at the point UVs.

Samples one channel of a COP layer at each point's UV and moves the point by (value - Midpoint) * Amount along the direction. This is the standard height-map or displacement-map workflow. Midpoint is the value that causes no movement: 0 for height maps whose lowest value is 0, 0.5 for displacement maps where 0.5 means flat.

The node does not recompute normals, so N is out of date after displacement. Append a Facet (or another normal-computing node) downstream if you need correct shading or further normal-based displacement. As with Attribute from Map, the image is read as numbers, so enable the sRGB decode when the data was stored as sRGB.

Inputs

Outputs

Parameters

Direction

UV

Fractal (PCG)#

PCG_Fractal · category PCG/deform · Houdini: Fractal (SOP)

Roughens a surface by midpoint displacement.

Each division level subdivides linearly, and only the points newly created in that level are pushed randomly along the normal (or a fixed vector) by up to Scale * Roughness^level. The first level therefore moves most and each following level moves less, which gives a fractal-looking surface.

With Fixed Boundary the new points on open borders are not moved, so adjacent tiles stay seamless.

Inputs

Outputs

Parameters

Lattice (PCG)#

PCG_Lattice · category PCG/deform · Houdini: Lattice (SOP)

Deforms geometry with a lattice using free-form deformation.

The geometry follows a control lattice that you move. Rest positions come from the rest attribute stored on the lattice points (as created by Lattice From Bound), or from the optional rest_lattice input.

Trilinear is local: each point only looks at the 8 control points of the cell it is in. Bezier is a global Sederberg-Parry Bernstein volume, smooth everywhere and well suited to large shape changes with 2 to 4 cells. Both have linear precision: when the whole lattice undergoes an affine transform, the geometry transforms exactly the same way. Normals are corrected with the inverse transpose Jacobian.

Inputs

Outputs

Parameters

Lattice From Bound (PCG)#

PCG_LatticeFromBound · category PCG/deform

Creates a grid of control points around the bounding box of the input, for use with Lattice.

Places (nx+1)(ny+1)(nz+1) control points on the bounding box of the input (connected with grid lines for easy viewing), each with a rest attribute. Move the points with any nodes, then connect the result to the lattice input of the Lattice node. Do not delete or merge points, since their order defines the lattice.

Inputs

Outputs

Parameters

Magnet (PCG)#

PCG_Magnet · category PCG/deform · Houdini: Magnet (SOP)

Transforms points inside the influence of a magnet geometry, weighted by falloff.

The influence region works as in Bulge: each magnet point is a sphere of radius pscale * Radius, or the distance to the magnet surface is used. Points inside are transformed by the Translate, Rotate and Scale parameters scaled by the weight: translation multiplied by the weight, rotation angle multiplied by the weight, and scale interpolated from 1 to the scale value. The transform is applied around the magnet centroid, the origin or a custom pivot. Interpolation is applied to the parameters, not to the result, so a rotation does not collapse the radius.

Inputs

Outputs

Parameters

Influence

Path Deform (PCG)#

PCG_PathDeform · category PCG/deform · Houdini: Path Deform (SOP)

Bends geometry along a curve.

Lays one axis of the input (Deform Axis, +Z by default) along the curve in the second input: the coordinate on that axis becomes a distance along the curve, the other two coordinates become offsets in the curve's frame there. Frames are rotation-minimising, so long shapes don't twist unless Roll or Twist ask for it.

With Stretch to Curve the input's length along the axis is fitted to the curve; without it the axis coordinate is used as arc length directly (times Scale). Offset slides the shape along the curve. Past the curve's ends the shape continues straight along the end tangent.

A coarse curve gives a faceted bend; resample it for smooth results.

Inputs

Outputs

Parameters

Point Deform (PCG)#

PCG_PointDeform · category PCG/deform · Houdini: Point Deform (SOP)

Deforms high-resolution geometry using the motion of a low-resolution point cloud.

rest holds the original positions of the low-res points and deformed the deformed positions (same point count and order). Each point of the input geometry is weighted against its nearest Max Points low-res points; the kernel radius is the distance to the (k+1)-th nearest point so weights stay continuous when neighbors change.

In Rigid mode the local rigid transform of every low-res point is estimated (Kabsch) and blended, so a pure rotation of the low-res cloud rotates the high-res geometry exactly and normals rotate with it. Translate Only blends just the displacements: cheaper, but it distorts under rotation.

Inputs

Outputs

Parameters

Soft Peak (PCG)#

PCG_SoftPeak · category PCG/deform · Houdini: Soft Peak (SOP)

Pushes a group of points along their normals, with nearby points following by a soft falloff.

The points in Group are the handle: each is pushed along its normal by Distance. Other points within Soft Radius follow, weighted by a falloff computed with the same soft selection as Soft Transform (straight-line distance, distance along edges, or number of edge steps). Normals are computed on the fly if the input has none.

With the Attribute metric there is no handle group: distances come from a point attribute, and Group only restricts which points may move (empty means all points). With Translate Along Lead Normal each point moves along the normal of its nearest handle point rather than its own, which pushes out a translated block instead of a mushroom shape.

Inputs

Outputs

Parameters

Soft Transform (PCG)#

PCG_SoftTransform · category PCG/deform · Houdini: Soft Transform (SOP)

Transforms a group of points and lets nearby points follow with a soft falloff.

Houdini's soft-selection drag as a reproducible node. The Group is the handle: weight 1 inside it, falling off with distance to 0 at Soft Radius. An empty group selects all points, which makes the node an ordinary transform.

The parameters are interpolated, not the result. Blending P with the transformed P by the weight is wrong for rotation, because the point travels along a chord and the radius shrinks (by almost 30% at weight 0.5 in a test case). Here each point builds its own matrix from angle * w, translation * w, lerp(1, scale, w) and shear * w, so rotation radius is preserved. Pivot Rotate orients the pivot's frame and is not weighted.

The distance metric decides how the falloff spreads. Straight-line distance works on point clouds but leaks through gaps (a separate piece across a gap is also affected); the edge-based metrics only spread across connected geometry. By default the pivot is the centroid of the handle group.

Inputs

Outputs

Parameters

Pivot

Spherify (PCG)#

PCG_Spherify · category PCG/deform

Pushes the selected points onto a sphere.

Computes P' = lerp(P, C + normalize(P - C) * R, Amount). With Radius 0 the radius is the average distance of the selected points to the center, which changes volume least; the center defaults to the centroid of the selected points. Amount 0 is exactly the identity and amount 1 puts all points on the sphere.

Use it with Group to spherify only part of a shape.

Inputs

Outputs

Parameters

Center

Topo Transfer (PCG)#

PCG_TopoTransfer · category PCG/deform · Houdini: Topo Transfer (SOP)

Fits the wiring of one mesh onto the shape of another.

Moves the points of geo onto the surface of target while keeping the original topology. First the meshes are aligned: with a similarity transform from landmark pairs when enough are available, otherwise by bounding box. Then it iterates: project the points onto the target surface and smooth the displacement field. The smoothing fades out over the iterations and the last iteration is a pure projection, so all points end on the target, the point density is preserved and faces do not flip.

Landmarks are an integer point attribute present on both meshes; points with equal values (0 or greater) are paired, and paired points are pinned in every iteration.

Inputs

Outputs

Parameters

Transform Pieces (PCG)#

PCG_TransformPieces · category PCG/deform · Houdini: Transform Pieces (SOP)

Moves pieces of a fragmented geometry onto the matching points of a template, such as RBD output or a skeleton.

The input is split into pieces by the name attribute (primitive attribute first, point attribute if the primitive one does not exist). Each piece is transformed by the instance attributes of the template point with the same name: P, orient, N + up, scale, pscale, pivot and transform, interpreted as in Copy to Points. Pieces without a matching template point are left alone and listed in the report.

With a rest input, the piece transform is the template composed with the inverse of the rest (for RBD exports and bones). Without it, the piece is first centered and then placed on the template point.

Inputs

Outputs

Parameters

Compared with Houdini

Center Pieces is an addition: when no rest input is connected, each piece is centered at the origin first. Turn it off to get Houdini's behavior.

Twist / Bend / Taper (PCG)#

PCG_Deform · category PCG/deform · Houdini: Bend (SOP), Twist (SOP)

Twists, bends, tapers, squashes or shears points along a chosen axis.

A purely per-point position function: topology and attributes are untouched, so it can be chained freely. For each point a normalized parameter t along the primary axis is computed, and the deformation amount is a function of t.

Outside the capture region (t < 0 or t > 1) the deformation continues rigidly: for Bend the extra length is carried along the end tangent, so that part stays straight and keeps its length instead of collapsing onto the end plane. Bend is numerically stable for tiny angles (it is written in a sinc form), and zero Angle / Scale 1 / Shear 0 give exactly the identity. Squash and Stretch preserves volume within the region: the axis is multiplied by Scale and the other directions by 1/sqrt(Scale).

The secondary axis (Up) decides which way a bend goes and which way a shear pushes; when it is parallel to the primary axis another direction is chosen automatically. Normals, if present, are corrected with the inverse transpose of a finite-difference Jacobian rather than recomputed, so curves and point clouds work and hard edges are preserved.

Inputs

Outputs

Parameters

Capture

Compared with Houdini

Combines the Twist and Bend SOPs and adds taper, squash and shear in one node.