Clone to Points

Instances a source shape at every point position, reading per-point attributes for rotation, scale, opacity, and color. Supports custom pivot modes and group filtering.

Category: Point Ops Menu path: Point Ops > CloneToPoints

Ports

Port	Type	Direction	Description
shape_in	shape	input	Source shape to clone (instanced at each point)
points_in	points	input	Point cloud defining instance positions
out	shape	output	Combined shape with all instances

Parameters

Param	Type	Default	Description
pivotMode	enum	Center	How to anchor the source shape at each point: Center, Origin, FirstPoint, LastPoint, or Custom
customPivot	vec2	(0, 0)	Pivot offset in source-local pixels (used when pivotMode is Custom)
group	string	(empty)	Name of a group attribute to filter by. Empty = clone all points.
groupThreshold	scalar	0.5	Minimum group attribute value for a point to be included. Points where the attribute is > groupThreshold receive clones.
distribution	enum	All	How source paths are distributed across target points: All (every path at every point — default), CyclePaths (one path per point, cycling), CycleByAttribute (group paths by distributionAttribute, one group per point).
distributionAttribute	string	glyphIndex	Path attribute name used to group paths in CycleByAttribute mode. Paths sharing the same value form one group — used by the text workflow to keep multi-contour glyphs together.

How It Works

CloneToPoints places a copy of the source shape at every point in the input point cloud (optionally filtered by a group). Each instance is transformed according to per-point attributes set upstream by PointAttributes:

• rotation — rotates the instance (radians)
• scale — uniform scale factor (multiplies instance size)
• opacity — stored as a path-level attribute on the instance's paths
• color — stored as a path-level attribute on the instance's paths

Pivot modes

The pivot is the anchor point used for rotation and scaling, and the point that gets placed at each target position. Different modes suit different creative goals:

Mode	Pivot location	Use for
Center	AABB center of the source shape	Scattering symmetric shapes (default)
Origin	The source shape's local origin (0, 0)	Shapes already authored with a meaningful origin
FirstPoint	Position of the shape's first point	"Branches growing from base" — a line or stem where point 0 is the root
LastPoint	Position of the shape's last point	Reverse-growing / tip-anchored instances
Custom	customPivot vec2 in source-local pixels	Fine control — e.g., anchoring a flower at its stem join

Rotation and scale always pivot around the selected anchor, and the anchor is what gets placed on each target point. Switching from Center to FirstPoint on a horizontal line, for example, shifts every instance so that the line's start touches the point rather than the line's midpoint.

Group filtering

When group is non-empty, CloneToPoints only clones points whose points.attributes[group] scalar value exceeds groupThreshold. Any named scalar attribute works — write it upstream via PointAttributes or ShapeAttributes (Custom target, field- or value-driven) to mark a subset of points, then reference that name here:

Grid -> PointAttributes (Custom, attribute: "buds", source: Field) -> CloneToPoints (group: "buds") -> DrawShape

Only points where "buds" exceeds groupThreshold receive instances; the rest are silently skipped.

Missing attribute: If the named group doesn't exist on the incoming points, no points match — a clear signal that the name is mis-spelled (better than silently cloning everything).

Soft selection: For continuous [0, 1] attributes (e.g. field-driven), raise or lower groupThreshold to tune how picky the filter is.

Distribution modes

distribution controls how the source shape's paths are spread across target points:

• All (default) — every source path is instanced at every target point. Output path count = N_points × N_paths.
• CyclePaths — one source path per target point, cycling when there are more points than paths. Output = N_points.
• CycleByAttribute — group source paths by distributionAttribute (a path-level attribute name), then each target point gets one group. Paths sharing the same attribute value appear together on the same point. Output depends on per-group path count.

The classic use case is text layout. TextToShape produces one path per glyph contour with a glyphIndex attribute — letters like "O" or "B" have multiple paths (outer outline + inner counter) sharing the same glyphIndex. CycleByAttribute with distributionAttribute = "glyphIndex" keeps the counters attached to the right letter:

Text("HELLO") -> TextToShape -> CloneToPoints
                                  ^ points_in: Grid (count: 5)
                                    distribution: CycleByAttribute
                                    distributionAttribute: "glyphIndex"

Each letter lands on one grid point, then downstream PointAdvect / PointAttributes / etc. can animate them independently.

Output

Each instance gets unique PointIds — segment references in the source shape are remapped to new IDs to avoid collisions across instances. The output is a single ShapeData containing all instances as separate paths, ready for DrawShape.

Per-point opacity and color become per-path attributes on the output shape. DrawShape reads these for its per-path grouped rendering path — each instance can have its own color and opacity without needing per-vertex attributes.

Usage Examples

Basic: Scatter shapes on a grid

Grid -> CloneToPoints (shape: Circle). Places a circle at every grid point. Connect the output to T2D -> DrawShape -> Output to render.

Varied instances

Grid -> PointAttributes (target: Scale, field: Noise.scalarField) -> PointAttributes (target: Rotation, field: Noise.scalarField) -> CloneToPoints (shape: Polygon) -> DrawShape. Each polygon instance gets a unique size and rotation driven by noise.

Branches anchored at their base

Line -> CloneToPoints (shape: thin Rectangle, pivotMode: FirstPoint) where the Rectangle is authored as a horizontal line from (0, 0) rightward. Each clone grows outward from the target point rather than being centered on it — the foundation of stem-and-branch structures.

Dandelion: stem with tangent-aligned branches

Line -> Resample (count: 64) -> TrimPath (animate end from 0 to 1) -> ShapeAttributes (target: Rotation, source: Tangent) -> CloneToPoints (shape: branch, pivotMode: FirstPoint). As the stem grows, branch clones appear rotated to follow the curve's tangent, all anchored at the base of the branch on the stem.

Selective cloning via groups

Grid (10x10) -> PointAttributes (Custom, attribute: hotspots, source: Field, field: Noise.scalarField) -> CloneToPoints (shape: Circle, group: hotspots, groupThreshold: 0.6). Clones only appear where noise is strong — an organic, clustered scatter.

Colored instances

Circle -> ResampleShape (count: 20) -> ShapeToPoints -> PointAttributes (target: Color, field: Gradient.colorField) -> CloneToPoints (shape: small Rectangle) -> DrawShape. Rectangles arranged in a ring, each colored by a gradient field.

Particle-like trails

Grid -> PointAdvect (field: Noise.vectorField) -> CloneToPoints (shape: small Circle) -> DrawShape. Points flow through a noise field, and each one carries a visible circle shape.

Tips

• Pivot choice matters for asymmetric shapes. A horizontal line authored from (0, 0) rightward will clone differently with Center (clones centered on each point) vs FirstPoint (left end of each clone touches the point). Pick the pivot that makes the clone sit naturally on the target.
• Group names are plain strings — no syntax. Type the same name in the upstream PointAttributes/ShapeAttributes attribute field and in CloneToPoints' group field. Typos mean "no match" (clear failure).
• For large point counts, keep the source shape simple (low vertex count) to manage tessellation cost in DrawShape.
• Per-path color from PointAttributes is picked up by DrawShape's grouped renderer automatically.
• The output bounds differ from either input — CloneToPoints is terminal in content bounds computation, which is why its AABB is recomputed from the instanced output rather than inherited from the source.
• Combine pivotMode: FirstPoint with ShapeAttributes (source: Tangent) on the upstream curve feeding points_in to get instances aligned to a path — the foundation of ropes, stems, and written-text effects.

Related Nodes

• PointAttributes — sets per-point rotation, scale, opacity, color before cloning (or a Custom scalar for group filtering)
• ShapeAttributes — Tangent rotation mode pairs with pivotMode: FirstPoint for curve-aligned instances
• Grid — regular point grid as clone targets
• ShapeToPoints — extract shape vertices as clone targets
• DrawShape — rasterize the cloned instances
• PointAdvect — animate clone positions over time
• TrimPath — grow the target curve over time for progressive cloning