Text to Points

Extract one Point per glyph from a Text layout. Pairs with Clone to Points / Point Advect / Point Attributes for text-driven point workflows.

Category: Points Menu path: Points > Text to Points

Ports

Port	Type	Direction	Description
text_in	text	input	Upstream Text node
out	points	output	One point per glyph, with layout-aware attributes

Parameters

Param	Type	Default	Description
position	enum	Origin	Where on each glyph the point lands: Origin (baseline-left, typography default) or Center (center of glyph AABB)

How It Works

Reads text_in's computed layout (one LayoutGlyph per visible character) and emits a PointsData with one point per glyph. Each point carries layout-aware attributes that downstream nodes can read:

Attribute	Type	Description
index	scalar	Positional index 0..N-1. Consumed by PointAttributes(source=Index) for per-letter styling ramps.
glyphIndex	scalar	Same value as index; exposed under the text-specific name to match TextToShape's path attribute.
lineIndex	scalar	Which line the glyph belongs to (0-based)
wordIndex	scalar	Which word within the text (0-based)
advance	scalar	Glyph advance width in comp pixels — useful for scale-by-width effects

Position modes:

• Origin — the glyph's typography origin (baseline-left). This is where the glyph's anchor lives in the layout; matches how TextToShape positions outlines.
• Center — center of the glyph's AABB. Good for rotating / scaling glyphs around their visual center instead of the baseline anchor. Zero-width glyphs (whitespace) fall back to Origin.

Output points live in the same coordinate space as TextToShape — origin-centered comp-pixel coords. Downstream Transform2D applies any composition-level placement.

Usage Examples

Letters as particles

Text("HELLO") → TextToPoints → PointAdvect ← Noise.vectorField → DrawPoints → Output

Each letter becomes a point that advects through the noise field. No glyph outlines needed — just the positions.

Letters flying off from their layout

Text → TextToPoints ─┐
                     ├─► CloneToPoints (distribution: CycleByAttribute, glyphIndex) ← TextToShape ← Text
                     │
                     └─► PointAdvect ← Vortex

Split the pipeline: TextToPoints drives animation (positions advect through vortex), TextToShape provides the outlines, CloneToPoints places each glyph at its advected position. Use lineIndex or wordIndex attributes upstream to stagger different lines / words.

Per-word color fades

Text("Hello world") → TextToPoints → PointAttributes (source=Custom, attribute=wordIndex→opacity mapping)

Use wordIndex to stagger opacity by word for word-by-word reveal effects.

Scale letters by advance width

TextToPoints → PointAttributes (target=Scale, source=Custom, customAttribute=advance) → CloneToPoints ← Circle

Each clone scales with the advance width of its glyph — wider letters get bigger circles.

Per-line stagger

TextToPoints → PointAttributes (source=Custom, attribute=lineIndex → use downstream to offset y)

Use lineIndex as input to downstream math to drive per-line animation offsets.

Tips

• Origin vs Center matters most for rotation and scale effects. Rotating around Origin spins each glyph around its baseline-left corner (glyphs swing outward); Center rotates in place.
• Whitespace glyphs are included — they appear as points too. If you don't want them, add a downstream PointDelete gated on advance > 0.
• Attributes are sampleable via PointAttributes Index source — run PointAttributes(source=Index, target=Color, ramp=red→blue) downstream to get a color gradient across letters.
• Pair with CloneToPoints(CycleByAttribute, glyphIndex) to apply per-glyph animation to each letter's outline independently.

Related Nodes

• TextToShape — emits glyph outlines as Shape paths (pair with this for full glyph-level animation)
• Text — the upstream Text node
• TextAnimate — per-glyph geometric animation (offset/scale/opacity/blur)
• CloneToPoints — instance shapes at the extracted point positions
• PointAttributes — sample ramps by the index / glyphIndex attribute for per-letter styling
• PointAdvect — advect glyph points through a vector field