Text Animate

Applies per-glyph geometric animation to text, with independent In and Out states. Outputs animated TextData and a reveal mask texture.

Category: Text Menu path: Text > Text Animate

Ports

Port	Type	Direction	Description
text_in	text	input	Source TextData (from Text or another TextAnimate)
offsetField_in	vectorField	input	Per-glyph position offset field. Sampled at each glyph's visual center, scaled by fieldOffsetAmplitude. eval_bipolar ([-1, 1]) semantics.
scaleField_in	scalarField	input	Per-glyph scale multiplier field. 1.0 = unchanged, 0.5 = half size, 2.0 = double. Applied around glyph center.
opacityField_in	scalarField	input	Per-glyph opacity multiplier field. Multiplies on top of the reveal opacity.
out	text	output	TextData with per-glyph animation transforms applied
reveal_mask	imageRgba16f	output	Grayscale texture showing per-glyph reveal state

Parameters

Timing

Param	Type	Default	Description
target	enum	Character	Granularity: Character, Word, Line, or All
stagger	scalar	50	Delay between elements in the animation sequence
order	enum	Forward	Stagger order: Forward / Reverse / Random / Center / Edges
seed	scalar	1	Seed for order: Random (deterministic permutation)
easing	enum	Smooth	Linear or Smooth (smoothstep)

Order modes:

• Forward / Reverse — sequential, first-to-last or last-to-first.
• Random — Fisher-Yates permutation seeded by seed. Same seed = same shuffle, so you can animate or keyframe the seed to reshuffle.
• Center — middle glyphs animate first, edges last. Expands outward.
• Edges — edges first, middle last. Collapses inward.

In (Entry Animation)

Param	Type	Default	Description
progress	scalar	0.5	In animation progress (0 = all hidden, 1 = all revealed)
offsetX	scalar	0	Horizontal offset of the From state
offsetY	scalar	50	Vertical offset of the From state (positive = below)
fromScale	scalar	1	Scale of the From state
fromRotation	scalar	0	Rotation of the From state (degrees, around each glyph's bounds center)
fromOpacity	scalar	0	Opacity of the From state (0 = invisible)
fromBlur	scalar	0	Blur radius of the From state

Out (Exit Animation)

Param	Type	Default	Description
outProgress	scalar	0	Out animation progress (0 = no exit, 1 = all exited)
outOffsetX	scalar	0	Horizontal offset of the Out state
outOffsetY	scalar	-50	Vertical offset of the Out state (negative = above)
outFromScale	scalar	1	Scale of the Out state
outFromRotation	scalar	0	Rotation of the Out state (degrees, around each glyph's bounds center)
outFromOpacity	scalar	0	Opacity of the Out state
outFromBlur	scalar	0	Blur radius of the Out state

Per-glyph field effects

After the In/Out animation transforms settle each glyph into its current position, optional field inputs drive additional per-glyph offset, scale, and opacity. Fields are sampled at each glyph's current visual center (AABB midpoint), in origin-centered comp-pixel coords — the same convention as every other field consumer.

Param	Type	Default	Description
fieldOffsetAmplitude	scalar	100	Pixel scale applied to offsetField_in output. With a unit vector field (eval_bipolar → [-1, 1]), the default gives glyph-scale motion (±100 px).

The field inputs are optional — disconnected fields no-op. Pair with Vortex / RadialForce / DistanceField / Noise / any other field source to drive per-letter motion, scale, or visibility from spatial primitives.

Signal interpretation:

• offsetField_in (vectorField): sampled via eval_bipolar (outputs in [-1, 1] range per axis), multiplied by fieldOffsetAmplitude to get pixel displacement. Direct addition to glyph position.
• scaleField_in (scalarField): sampled via eval ([0, 1] for most sources). Used as a direct multiplier: field=1 → unchanged, field=0 → collapsed glyph, field=2 → doubled. Use a Remap node upstream to hit different ranges.
• opacityField_in (scalarField): sampled via eval, clamped to [0, 1]. Multiplies the existing reveal opacity (from In/Out progress + from-state).

Expose Channels

When enabled (E button on node header), adds input ports that override params via edge connections:

Port	Type	Overrides
progress_in	scalar	progress
stagger_in	scalar	stagger
offset_in	vec2	offsetX and offsetY
fromScale_in	scalar	fromScale
fromRotation_in	scalar	fromRotation (degrees)
fromOpacity_in	scalar	fromOpacity
fromBlur_in	scalar	fromBlur
outProgress_in	scalar	outProgress
outOffset_in	vec2	outOffsetX and outOffsetY
outFromScale_in	scalar	outFromScale
outFromRotation_in	scalar	outFromRotation (degrees)
outFromOpacity_in	scalar	outFromOpacity
outFromBlur_in	scalar	outFromBlur

How It Works

TextAnimate is a geometric modifier, not a render effect. It modifies per-glyph position, scale, opacity, and blur values in the TextData before it reaches a DrawText node.

Each glyph (or word/line/all, depending on target) gets an individual animation progress based on its index in the sequence, the stagger delay, and the global progress value. The element interpolates between its From state and its resting (fully revealed) state.

The In animation brings elements from the From state to their natural position. The Out animation moves elements from their natural position to the Out state. Both can be active simultaneously for a typewriter-style "rolling window" effect.

The reveal_mask output is a grayscale texture where each glyph's area is white (revealed) or black (hidden), useful for masking other effects.

When connected to DrawText with applyReveal enabled, per-glyph blur and opacity from TextAnimate are applied during rasterization.

Usage Examples

Basic: Fade-up character reveal

Text -> TextAnimate (progress: keyframed 0 to 1, offsetY: 50, fromOpacity: 0) -> DrawText -> Transform2D -> Output. Characters fade in from below, one at a time.

Word-by-word with blur

Set target to Word. Set fromBlur to 20 and fromOpacity to 0. Keyframe progress from 0 to 1. Words sharpen and appear sequentially.

In and Out (rolling window)

Keyframe both progress (0 to 1) and outProgress (0 to 1, starting slightly later). Characters enter from below and exit upward, creating a scrolling reveal.

Scale pop

Set fromScale to 0.5, fromOpacity to 0, offsetY to 0. Characters pop in from half-size to full-size.

Tumble in

Set fromRotation to -90 (or +90), offsetY to 50, fromOpacity to 0. Characters spin into place as they fall. Try order: Random for a scatter effect.

Scramble

Set order: Random and keyframe seed over time — the stagger permutation shuffles, so characters animate in a different order each time. Pair with target: Character and short stagger for a quick scramble.

Expand from middle

Set order: Center, keyframe progress from 0 to 1. Characters nearest the middle animate first, edges last — good for emphasis reveals.

Tips

• TextAnimate modifies TextData, not pixels -- always follow with DrawText for rendering
• You can chain multiple TextAnimate nodes for layered animation effects
• The reveal_mask output is useful for driving other effects (e.g., connect to a Mix node's mask input)
• stagger controls the overlap between elements -- higher values mean more sequential, lower values mean more simultaneous
• Set target to All for a uniform fade/scale of the entire text block

Related Nodes

• Text -- creates the source TextData
• DrawText -- rasterizes the animated TextData (applyReveal applies per-glyph blur/opacity)
• TextToShape -- alternative path: convert text to shape outlines