Advanced Effects

Once you master basic tag mapping, you can create richer text animations through UGlyphAnimation keyframe editing, FGlyphScheduleInfo per-glyph timing, and multi-layer composition.

Deep Editing with UGlyphAnimation

Applies to: keyframe-level precise editing of text animations in Sequencer.

UGlyphAnimation is a UMovieSceneSequence subclass — double-click the asset to open it in Sequencer:

1. Double-click a glyph animation asset (UGlyphAnimation) in the Content Browser
2. Sequencer opens showing the animation’s timeline
3. Add typed sub-tracks (UMovieSceneGlyphAnimationSection) and edit FloatChannel keyframes and curves
4. Query asset properties with the Blueprint nodes Get Duration / Get Track Types / Has Track Type

The 10 Editable Track Types (21 Channels)

Track type	Channels	Description
Opacity	1	Opacity (default 1.0)
LetterSpacing	1	Letter spacing (pixels)
Rotation	1	Rotation (degrees)
Translation	2	Position offset X / Y (pixels)
Scale	2	Scale X / Y (default 1.0)
Shear	2	Shear transform X / Y
Pivot	2	Pivot X / Y (default 0.5)
ShadowOffset	2	Shadow offset X / Y (pixels)
Color	4	Tint R / G / B / A (A = tint share)
ShadowColor	4	Shadow color R / G / B / A

TIP

The most common channel combination is Opacity + Translation + Scale + Rotation, covering most text animation needs. Tint (Color) controls the tint share via the A channel (A=1 fully tinted).

Per-Glyph Timing Control

Applies to: adjusting each glyph’s playback delay and scheduling to control per-glyph animation rhythm.

Scheduling API

Controlled via UGlyphAnimationLayer scheduling functions (Index = -1 applies to all):

// Create a layer (must specify an animation asset and blend mode)
TArray<FGlyphScheduleInfo> Schedule = FAnimationCompiler::BuildScheduleInfos(Text);
UGlyphAnimationLayer* Layer = UGlyphAnimationLayer::CreateLayer(
    AnimAsset, ETextAnimationBlendMode::Override, Schedule);

// Per-glyph staggering
Layer->SetStartDelayAt(-1, 0.0f);   // base start delay
Layer->SetDelayAt(-1, 0.05f);       // glyph i delay = 0 + i × 0.05
Layer->SkipAt(-1);                  // batch skip
Layer->SetSkipAnimationAt(3, false);// restore glyph 3

Per-Glyph Delay Example

10 glyphs, staggered 0.05s → glyph 10 starts at 0.45s, total animation ≈ 0.5s

NOTE

Skipping (SkipAt) only skips that glyph’s animation (static display), not rendering — whitespace characters still occupy layout space. Whitespace/punctuation/CJK classification can be queried with IsWhitespaceAt / IsPunctuationAt / IsCJKAt / IsDecoratorAt.

Multi-Layer Composition

Applies to: baking multiple UGlyphAnimationLayers together into composite animation effects.

UGlyphAnimationFactory

// 1. Create a factory (requires a base layer + schedule)
UGlyphAnimationFactory* Factory = UGlyphAnimationFactory::CreateFactory(BaseLayer, Schedule);

// 2. Add layers (later layers have higher priority)
Factory->AddLayer(WaveLayer);
Factory->AddLayer(ShakeLayer);

// 3. Factory-level tweaks (applied to the final blended state)
Factory->MultiplyTranslationAt(-1, FVector2D(1.5f, 1.0f));

// 4. Bake
FBakedStage Stage = Factory->Bake();

Each layer independently defines curves and scheduling; blending is determined by ETextAnimationBlendMode when merging:

Mode	Semantics	Typical use
Override	Overrides existing values	Base layer
Additive	Adds to existing values	Shake/wave overlay layers
Multiply	Multiplies with existing values	Global modulation
CrossFade	Interpolates with existing values	Blend transitions

NOTE

Default implementation convention: GlyphAnimations[0] is the base layer (Override), GlyphAnimations[1..N] are overlay layers (Additive). The blend mode must be explicitly specified when creating a layer; there is no implicit default.

Animation Clipping

Applies to: trimming the front/back of animation curves, keeping only the valid range.

Layer->SetAnimationClipAt(0.1f, 0.0f);     // skip the first 0.1s
Factory->SetAnimationClipAt(0.0f, 0.3f);   // factory-level: trim 0.3s off the end

Playback-axis semantics: front trim skips the beginning, back trim ends playback early; finite loops are materialized as expansion (only the last loop is modified).

Runtime Stage Control

Applies to: dynamically controlling stage playback in Blueprint or C++.

UTextAnimationStageController controls the stage playback flow:

1. Manual path: FAnimationCompiler::BakeAllStages(BP, Text) → Initialize(&Baked, BP) → Play()
2. UMG path: the widget does this automatically — just call the Play node
3. Set Play Direction (EStagePlayDirection): Forward / Reverse / PingPong
4. Set Loop: loop stage playback
5. Tick Animation: advance per frame (automatic for widgets)
6. Reveal All: skip animations and display all text immediately

Stage State Queries

EStagePlaybackState reflects the current playback state:

• Stopped — not playing
• Playing — playing
• Paused — paused
• Complete — playback complete

Performance Recommendations

Applies to: optimizing runtime performance with long text or many glyph animations.

1. FBakedGlyph::Evaluate evaluates every non-static glyph each frame — for long text (>100 glyphs), use scheduling delays so most glyphs are “not started/completed”, reducing the number of active glyphs
2. Baking is throttled by fingerprint caching (MinFramesBetweenRebakes = 3 cooldown) — no redundant baking at runtime
3. Skip empty channels: delete unused tracks to reduce evaluation channels
4. Rich text multi-entries: split long dialogs into short segments and use bSequentialPlayback instead of playing everything simultaneously

TIP

For long text (>100 glyphs), split it into multiple segments, each with its own UAnimatedRichTextBlock widget, and play on demand instead of keeping everything resident.