Scatter & Copy#

Scatter points and copy geometry onto them.

15 nodes.

Back to the reference index

Contents#

• Adaptive Prune (PCG) — Thins a point cloud so that no two remaining points are closer than a radius, keeping points greedily by priority.
• Assemble (PCG) — Names the connected pieces of a mesh piece0, piece1 ... and optionally packs each piece.
• Chain (PCG) — Lays out source pieces one after another along curves, as rigid links or deformed to follow the curve.
• Copy and Transform (PCG) — Makes several copies of the input, where copy k has the same transform applied k times.
• Copy to Curves (PCG) — Copies source geometry along curves, at sampled positions or on the curves' existing points, oriented by the curve frame.
• Copy to Points (PCG) — Copies source geometry onto each target point, oriented and scaled by the point's instance attributes.
• Pack (PCG) — Packs pieces of geometry into packed primitives: one point per piece.
• Point Relax (PCG) — Pushes points apart until their radii no longer overlap.
• Point Replicate (PCG) — Scatters a cluster of new points around each source point.
• Scatter (PCG) — Scatters points over the surface of polygons, by total count, density or per-primitive count.
• Scatter and Align (PCG) — Scatters points on a surface and writes a ready-to-use instance frame: scale, normal, up vector and orientation.
• Scatter from Map (PCG) — Scatters points on a surface with an image as the density field, using rejection sampling at each point's own UV.
• Scatter in Volume (PCG) — Scatters points inside a closed piece of geometry, randomly or on a jittered grid.
• Unpack (PCG) — Expands packed primitives back into real geometry.
• Voronoi 2D (PCG) — Builds a planar Voronoi diagram from points and outputs either cell polygons or their boundary lines.

Nodes#

Adaptive Prune (PCG)#

PCG_AdaptivePrune · category PCG/scatter · Houdini: Adaptive Prune (SOP)

Thins a point cloud so that no two remaining points are closer than a radius, keeping points greedily by priority.

Visits points in priority order and keeps a point only if it does not conflict with an already kept one. Two points conflict when their distance is below the larger of their two radii, where each point's radius is Radius (optionally multiplied by a point attribute). The result is a set of kept points that are pairwise non-conflicting, and every removed point sits next to a kept point of higher priority.

With Group Pruned Points the removed points are only put into a point group and nothing is deleted; the report output summarises the result.

Inputs

Outputs

Parameters

Tips

• Use Attribute priority with pscale to let large instances win over small ones.

Assemble (PCG)#

PCG_Assemble · category PCG/scatter · Houdini: Assemble (SOP)

Names the connected pieces of a mesh piece0, piece1 ... and optionally packs each piece.

Finds the connected pieces among the group's primitives (primitives sharing points belong together) and writes Output Prefix plus the piece number into a string primitive attribute, numbered in order of each piece's first primitive. This is the usual step after a fracture or a Boolean that leaves loose parts.

With Create Packed Geometry every piece becomes a packed primitive placed at its pivot, ready to be moved per piece, instanced in the viewport or exported with GPU instancing. Primitives outside the group pass through unchanged.

Inputs

Outputs

Parameters

Compared with Houdini

Counterpart of the Assemble SOP. Connectivity is by shared points; there is no separate Connectivity Attribute, and the packed fragments carry no path attribute.

Chain (PCG)#

PCG_Chain · category PCG/scatter · Houdini: Chain (SOP)

Lays out source pieces one after another along curves, as rigid links or deformed to follow the curve.

Two modes.

Rigid Links places each link as a rigid piece along the curve. Every link takes up its own bounding box length along local Z plus Piece Spacing; a negative spacing makes links overlap, as in chain rings. The link centre sits at the midpoint of the chord, +Z points along the chord, and on bends both ends lie on the curve. Neighbouring links are rotated by an extra Roll per Link (90 degrees by default for alternating chain links), counting from 0 on every curve. Fit to Curve adjusts the gaps equally so that the last link ends exactly at the end of the curve (a closed curve closes exactly), with the spacing only deciding how many links fit. With a piece attribute, several link types alternate.

Deform Along Curve is Houdini's Chain. The source is split into pieces by connectivity or by a piece attribute. The pieces are arranged into a chain following a pattern (cycle, explicit, random, weighted random), each piece's length being its bounding box length along the Forward axis times the piece scale plus spacing. The chain is then mapped onto the curve (see Map Length and Offset): every point is placed in the curve frame at its position, so each piece follows the bends of the curve. The curve frame uses the averaged tangent interpolated within segments and an up vector carried along the curve. Beyond the ends the geometry is extended along the end tangent, clamped to the end point, or clipped. Closed curves wrap around.

The output carries a copy number attribute and optionally the position, index and curve number along the curve.

Inputs

Outputs

Parameters

Chain Pattern

Pattern

Deformation

Alignment

Attributes

Compared with Houdini

Deform Along Curve corresponds to Houdini's Chain. Rigid Links is the plugin's own earlier method, which places whole links rigidly on the chord.

Copy and Transform (PCG)#

PCG_CopyAndTransform · category PCG/scatter · Houdini: Copy and Transform (SOP)

Makes several copies of the input, where copy k has the same transform applied k times.

Produces Total Number copies including the original. Copy k is transformed by the same transform applied k times: scale and rotation happen about the pivot, followed by the translation. Spiral stairs, for example, are a rotation of 30 degrees plus a lift of 1 per copy; nested copies are a scale of 0.9 per copy.

The matrices are multiplied together, not approximated as separate t*k and R^k terms. Normals follow with the inverse transpose. The copy index is written to the copy-number attribute on both points and primitives.

Inputs

Outputs

Parameters

Copy to Curves (PCG)#

PCG_CopyToCurves · category PCG/scatter · Houdini: Copy to Curves (SOP)

Copies source geometry along curves, at sampled positions or on the curves' existing points, oriented by the curve frame.

Two families of modes. In Count and Spacing mode, points are taken along each curve by count (both ends included) or by spacing, and the orientation is the rotation-minimising frame used by Orient Along Curve: +Z along the curve and +Y as the up vector. The copies are then placed as in Copy to Points. Start / End Offset leave out a stretch of arc length at each end. A closed curve does not repeat a copy at its start. Roll per Copy rotates copy k by an additional k times the step (alternating fence posts, spirals), where k counts from 0 on every curve separately, as in Chain.

Curve Points follows Houdini's Copy to Curves: the source is copied onto every existing point of each curve without resampling. The Frame, Additional Rotations and Scales settings only act in this mode. The frame is made of the tangent (see Tangent Type) and an up vector carried along the curve by rotation-minimising transport, followed by extra rotation in the curve frame (roll or twist about the tangent, yaw about the up axis, pitch about the outward axis), then scale and optional stretch at turns. On closed curves, leftover twist is spread so that it adds up to a whole turn.

If a piece attribute is given, the source is split into pieces and copies cycle through them in order (in Curve Points mode the attribute on the curve point selects the piece if it exists, otherwise they cycle). The output carries curvenum (index of the source curve) and the copy number attribute.

Inputs

Outputs

Parameters

Copy

Frame

Additional Rotations

Scales and Shears

Attributes

Copy to Points (PCG)#

PCG_CopyToPoints · category PCG/scatter · Houdini: Copy to Points (SOP)

Copies source geometry onto each target point, oriented and scaled by the point's instance attributes.

Follows the Houdini instance attribute convention. Target points may carry orient, N with up, rot, scale, pscale, pivot, trans or transform. The transform is composed as P + trans + orient * (rot * (scale * (p - pivot))), so the N and random pscale produced by the scatter nodes can be plugged in directly. A transform attribute is read in Houdini's convention (p' = p * M, translation of a 4x4 in the fourth row).

When a piece attribute is given (for example name or variant), the source is split into pieces by that attribute and each target point picks the piece whose value matches its own attribute. This lets several variants, such as five tree types, be scattered in one node.

Inputs

Outputs

Parameters

Attributes from Target

Pack (PCG)#

PCG_Pack · category PCG/scatter · Houdini: Pack (SOP)

Packs pieces of geometry into packed primitives: one point per piece.

Turns every piece of the input into a packed primitive: a single point that carries the whole piece. Pieces are defined by a piece attribute (such as name), by connectivity, or the whole input is one piece. The piece's pivot (centroid, bounding box center, bottom center or origin) becomes the packed point.

Packed geometry is cheap to transform, merge and copy, and the viewport draws it as GPU instances. Nodes that need real polygons unpack it automatically, so a packed input never gives a wrong result.

Inputs

Outputs

Parameters

Point Relax (PCG)#

PCG_PointRelax · category PCG/scatter · Houdini: Point Relax (SOP)

Pushes points apart until their radii no longer overlap.

Each point is a sphere whose radius is pscale times Point Radius Scale, or the Point Radius value when there is no pscale or it is switched off. A radius of 0 is determined automatically. Overlapping points push each other away over several iterations.

With a surface connected, every step projects the points back onto it. Points outside the group do not move but still block the others. A point moves by at most Max Step times its radius per iteration, and relaxation stops early once nothing overlaps.

Inputs

Outputs

Parameters

Point Replicate (PCG)#

PCG_PointReplicate · category PCG/scatter · Houdini: Point Replicate (SOP)

Scatters a cluster of new points around each source point.

Every selected point spawns Points per Point new points (or a count read from an attribute) around itself. There are two families of shapes. Sphere, Shell, Disk and Gaussian are offsets in world space scaled by Radius times the radius attribute (pscale by default): sphere fills a ball uniformly, shell puts points on its surface, disk is a flat disc perpendicular to N (the Y axis if there is no N), and gaussian uses a normal distribution with the radius as its standard deviation. Circle, Line and Grid are generated in local space, controlled by Orientation, Center, Size and Uniform Scale, and then placed on each source point with the same instance rules as Copy to Points (orient, N with up, pscale, scale, trans, pivot, transform). These three ignore Radius.

Every source point draws its own random numbers from the seed and its id attribute (or its point number if there is no id), so adding or deleting other points does not change the cluster around a point. New points inherit the source point's attributes and get a point attribute with the source point number (source by default).

Inputs

Outputs

Parameters

Attributes

Scatter (PCG)#

PCG_Scatter · category PCG/scatter · Houdini: Scatter (SOP)

Scatters points over the surface of polygons, by total count, density or per-primitive count.

Faces are triangulated with ear clipping, not fans, so concave n-gons stay inside their outline and no points land outside the face. Points are drawn with probability proportional to triangle area, multiplied by a density attribute when enabled.

Generate chooses the model. By Density draws either a fixed total number of points (Force Total Count) or Density Scale times the weighted total area. An optional density texture on the second input is sampled at the surface's UVs and accepts points with probability proportional to the texture value, so the density precision depends only on the texture resolution and not on the mesh. Count per Primitive gives each primitive an exact number of points. In Texture Space scatters in the UV unit square and keeps the points that fall within the UV area of the surface.

Relaxation pushes the random points apart into a blue-noise-like distribution. After every iteration the points are projected back onto the nearest triangle, so they can migrate across triangles and do not drift off the surface. The relaxation radius is estimated from the target density as sqrt(total area / (N * pi)), the radius of N non-overlapping discs filling the area. With Count per Primitive, relaxation runs per primitive so points stay on their own primitive.

With Primitive Seed each primitive has its own random stream, so editing one face does not reshuffle the points on the others. This is slower because it samples face by face.

The node outputs a point cloud only. Point attributes (and vertex attributes, such as UVs, interpolated by corner) are interpolated barycentrically from the source; primitive and detail attributes are copied.

Inputs

Outputs

Parameters

Density

Density › Density Attributes

Density

Density › Per-Prim Seed

Density

Relax › Relax

Output Attributes › Output Attributes

Output Attributes

Attributes

Compared with Houdini

Scatter on Voxels Independently is not implemented: the node scatters on surfaces only, not on volumes (see Scatter Volume). Primitive and detail attribute patterns copy attributes only; groups are not copied.

Tips

• Use Primitive Seed when the surface is edited procedurally, to keep points on unchanged faces from reshuffling.
• Feed N and pscale into Copy to Points directly: this node's normal and radius outputs follow the same conventions.

Scatter and Align (PCG)#

PCG_ScatterAlign · category PCG/scatter · Houdini: Scatter and Align (SOP)

Scatters points on a surface and writes a ready-to-use instance frame: scale, normal, up vector and orientation.

A scatter node plus the attributes that Copy to Points needs, in one step. The point count follows from Point Count Method: a total, a density, a coverage (the fraction of the area covered by discs of radius pscale, which gives N = Coverage * area / (pi * E[pscale^2])), or a spacing for hexagonal packing (N = area / (sqrt(3)/2 * Spacing^2)).

Each point gets pscale, a random value between the min and max radius; N, the surface normal (interpolated point normals when the surface has them); up, the Up Vector projected onto the tangent plane and rotated randomly about N; and orient, a quaternion of the same frame. By default instance +Z is aligned to N and +Y to up, the same convention as Copy to Points. Max Random Cone Angle tilts the normal in a random direction so that grass or rocks are not all upright.

Remove Overlapping pushes the points apart on the surface (using Point Relax with pscale times the radius scale) so that instances do not interpenetrate; normals are then recomputed at the new positions. The random numbers depend only on the seed, so the same input gives the same result.

In Existing Points mode nothing is scattered. The attributes are written onto the points of the second input instead. The normal comes from the nearest surface triangle of the first input (also writing sourceprim); without faces it comes from the point's own N, else +Y. Points outside the point group keep their attributes, and newly created attributes get unit-instance values (pscale 1, identity orient).

Inputs

Outputs

Parameters

Orientation

Point Generation

Attributes

Compared with Houdini

Scatter Points Around Constraint Points is not implemented. The default for Normal Direction is Z instead of Houdini's Y, to keep earlier graphs unchanged. Houdini always writes the tag attribute; here it is written only when a tag name is given.

Tips

• Connect the result straight to Copy to Points; no further attribute work is needed.

Scatter from Map (PCG)#

PCG_ScatterFromMap · category PCG/scatter · Houdini: HeightField Scatter (SOP)

Scatters points on a surface with an image as the density field, using rejection sampling at each point's own UV.

Typical use: planting grass or placing rocks from an AI-generated mask.

The obvious alternative, writing the image into a density point attribute and feeding it to Scatter, ties the density precision to the mesh resolution, because Scatter averages the attribute over the three corners of a triangle. A 2x2 grid under a 1024x1024 mask would see only 4 values. This node instead scatters more points than needed (Oversample), looks up the image at each point's own UV, and keeps the point with probability density / max. The precision is limited only by the image resolution, not by the mesh.

The cost is that the count is not exact, so the Total Point Count method repeats rounds with a new seed, adjusting the number of candidates with the previous acceptance rate, until enough points are accepted; surplus points are cut. The probability is normalised by the maximum of the whole image, so one isolated bright pixel lowers the acceptance everywhere and costs extra rounds. Blur the image or clamp the highlights if that happens.

The order of processing is decode, invert, floor, scatter. Density Scale multiplies only the written density attribute, since the count is fixed and the probability is normalised, so scaling cannot change the distribution. With By Density and By Coverage, the count is not fixed: candidates are drawn at lambda * area * max(mask) and thinned in one round, so the expected count is lambda times the integral of the mask over the area.

Optional post-processing writes pscale and footprint (Variability), N and orient (Randomize Orients), quantised positions and a tag attribute. Nothing is added when these options are at their defaults. The second output is the number of points.

Inputs

Outputs

Parameters

Sampling

UV

Compared with Houdini

Corresponds to HeightField Scatter. Per Point Count using Source Points is not implemented. The Relax Iterations value is not used; use Point Relax downstream for blue-noise spacing.

Scatter in Volume (PCG)#

PCG_ScatterVolume · category PCG/scatter · Houdini: Points from Volume (SOP)

Scatters points inside a closed piece of geometry, randomly or on a jittered grid.

The points are in the interior, so they make solid seeds for Voronoi Fracture; surface scatter would give cells hugging the shell, resulting in shards instead of solid chunks.

Random scatters in the bounding box and discards points outside the geometry (rejection sampling). The distribution is truly random, so there are sparse and dense regions, and Voronoi fracturing gives uneven chunk sizes like natural breakage. Grid uses a jittered regular grid, giving similar chunk sizes like man-made cutting. The hit rate is volume divided by bounding box volume, which can be a few percent for a thin diagonal bar, so batches are drawn and the rate re-estimated until the count is reached.

Inside tests use ray parity and require a closed surface; an open mesh is rejected with an error (close it with PolyFill first). With Min Distance above 0 a Poisson-disc filter is applied using a spatial grid (linear time). No further points are added afterwards, so the final count can fall below the target.

Inputs

Outputs

Parameters

Compared with Houdini

Corresponds to Scatter combined with a volume (Points from Volume).

Unpack (PCG)#

PCG_Unpack · category PCG/scatter · Houdini: Unpack (SOP)

Expands packed primitives back into real geometry.

Replaces packed primitives with the geometry they carry, transformed to where they are; other primitives pass through. Copies made by Copy to Points with Pack and Instance unpack to exactly what Copy to Points gives without packing, attributes included.

Transfer Attributes copies attributes of the packed points and primitives (such as a colour set after packing) onto the unpacked pieces.

Inputs

Outputs

Parameters

Voronoi 2D (PCG)#

PCG_Voronoi2D · category PCG/scatter

Builds a planar Voronoi diagram from points and outputs either cell polygons or their boundary lines.

The dual of a Delaunay triangulation: scatter points in, get city-block-like cells out. It is the 2D partitioning counterpart of the 3D Voronoi Fracture node, which cuts solids into chunks. A typical road-network chain is Scatter, Voronoi 2D (edges), PolyPath, PolyExpand2D for the road width; what remains in between are the blocks.

Each site's cell is the boundary region clipped by the perpendicular bisector between the site and each of its Delaunay neighbours. Because the cell is always bounded, sites on the convex hull and inside use the same code path, and no unbounded cells need special handling. For this reason the boundary region must be convex: with Polygon the convexity is checked and an error is raised if it fails. For a concave outline, compute with a bounding box and then cut with Boolean or Clip.

The output points are new points (Voronoi vertices) with no relation to the sites, so point attributes are not carried down. Each cell gets a primitive attribute (default site) with the site's point number. Vertices shared between neighbouring cells are welded, so the lines can be joined into a network.

Inputs

Outputs

Parameters

Plane

Local Attributes

Advanced