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
shapes_in	shape	input (multi)	Source shape(s) to clone. Connect 2+ shapes to form a palette — each point picks one via selectionMode
points_in	points	input	Point cloud defining instance positions
out	shape	output	Combined shape with all instances

Parameters

Param	Type	Default	Description
fitMode	enum	None	Cell Fit: None (legacy size), Fit (contain, preserving aspect), Stretch (independent X/Y). Uses each target’s cellSize Vec2
pivot	enum	Center	How to anchor the source shape at each point: Center, Origin, FirstPoint, LastPoint, or Custom
pivotOffset	vec2	(0, 0)	Pivot offset in source-local pixels (used when pivot is Custom)
group	string	(empty)	Name of a group column to filter by — an attribute or an intrinsic. 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.
selectionMode	enum	Sequential	With 2+ shapes connected, how each point picks from the palette: Sequential (in point order, i mod N), Random (seeded hash of the point's id), Point Index (reads a shapeIndex column written on the point — write it with PointAttributes' Custom target; with no such column it falls back to the same stable id-hash Random uses)
seed	scalar	0	Seed for Random selection

Expose Channels

None. Per-point attributes control individual clones.

Choosing a mode for particles

Random hashes the point's id, which never changes once a point is born, so a particle keeps the same palette shape for its whole life even as neighbours are born and die around it. Point Index behaves the same way when nothing wrote a shapeIndex column.

Sequential is positional by definition — it reads a point's place in the stream, and that place is renumbered whenever membership changes. On a static cloud (a Grid, a scatter) that is exactly what you want. On a particle system it means a piece changes shape every time another piece expires, which reads as flickering. Use Random there.

To choose the shapes yourself, write a shapeIndex column (PointAttributes, Custom target, attribute name shapeIndex) and pick Point Index — that column is read verbatim. Do not select on the builtin index: it is an order, not an identity, renumbered 0…n on every membership change, so a selection made from it reshuffles as soon as points die. index is not read by variant selection for exactly that reason.

How It Works

Draw Shape’s Local fill/stroke mapping travels with each clone’s translation, rotation and scale, including nested cloning and shape palettes. Each piece keeps its source frame; the renderer samples one shared source texture rather than fitting an image to each clone. Canvas mapping remains fixed in composition space.

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 — scale factor (multiplies instance size). Uniform when written by the Scale target; per-axis [x, y] when written by Scale X/Y — instances stretch along their local axes (scaling applies before rotation)
• opacity — stored as a path-level attribute on the instance's paths
• color — stored as a path-level attribute on the instance's paths

Fitting shapes to cells

Wire Layout.cells, or a Cell Selected/Remaining stream (optionally through MergePoints), into points_in. Cell Fit appears when the actual point stream carries a Vec2 cellSize. It remains available while the stream is not yet inspected, and an enabled setting stays resettable after disconnecting or losing sizes.

• None preserves the original clone size and pivot behavior, including old projects with no setting.
• Fit scales uniformly to contain the chosen source shape in each box.
• Stretch scales X/Y independently to match the box dimensions.

Sizing uses actual curve bounds of the chosen palette shape, or of the chosen distribution path group for a single source. Center uses that curve-bounds midpoint while fitting. Other pivots retain their existing anchor, so an off-centre anchor can place some geometry outside the box. Per-point scalar/Vec2 scale multiplies after fitting, then rotation applies as before. There is no Fill mode, cropping, masking, or post-rotation containment guarantee. Local fill/stroke mapping follows the fitted geometry.

A missing, short, wrongly typed, zero, negative or non-finite box falls back to the original scale/pivot for that point. Lines fit along their nonzero axis; points remain unchanged. A custom cellSize must be Vec2, not a scalar: PointAttributes Custom, name cellSize, with a vectorField input writes Vec2 (both sampled components must be positive pixel sizes). Its ordinary Value field writes Scalar and does not make a box. For example a Vortex vector field sampled in a region where both components are positive can supply custom boxes; the dimensions are the actual sampled components, not a normalized size preset.

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	pivotOffset 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). Note the distinction: an empty name means "no filter", a named but unresolved one means "nothing selected".

Intrinsic Names

Any attribute-name field here also accepts an intrinsic — a property every element has by virtue of existing, computed on read and never stored. The leading @ is a reserved namespace: no attribute may be named with one, so a name starting with @ never hits the attribute map.

Name	Value
@index	Position in the list, starting at 0
@id	Stable PointId — survives filtering and reordering
@x / @y	Position, in local geometry space
@n	Total number of elements
@indexnorm	@index / (@n - 1), normalized 0–1
@rand01	Deterministic 0–1 per element, keyed on @id (stable as neighbours come and go)
@speed	Speed in pixels per second, from the velocity attribute (0 where there is none)

Names are case-insensitive (@Y = @y). A misspelled intrinsic (@bogus) resolves to nothing rather than falling through to an attribute lookup.

Non-scalar attributes reduce to a scalar by one rule everywhere: Vec2/Vec3 → magnitude, Vec4 → Rec.709 luma of RGB.

So group = "@x" with groupThreshold = 0 clones only the right-hand half of the stream, and group = "@rand01" with groupThreshold = 0.8 clones a stable random 20% — neither needs a PointAttributes node upstream.

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

Logos in unequal cells

Layout.cells → CloneToPoints.points_in, with a vector logo connected to shapes_in, Cell Fit = Fit, then DrawShape. Each logo fits its own cell while retaining its aspect ratio. Animate the Layout track sizes to resize the logos.

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, pivot: 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, pivot: 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 pivot: 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 pivot: 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
• DrawInstances — the texture-domain counterpart: stamps rendered pixels (images, effect chains, layer outputs) at points instead of live geometry