Docsv3.31.0
Back to API Reference
Class

EffectModifier

abstract
Inherits:BaseModifier
Implements:ILayer

Base class for modifiers that append duplicate glyph geometry behind or in front of the face (outline, shadow, extrude, glow, custom effects).

Remarks

Contract: At the geometry-consumer tail of onGlyph, after glyph transformations, the subclass's OnGlyphEffect decides whether the current glyph needs an effect quad and, if so, calls EnqueueDuplicate with an arbitrary payload integer — typically an index into the modifier's own per-emit data table. At onMainPassFinalize, the per-modifier emit queue is flushed via OnFlush. The default implementation reserves 4 vertices for each pending emit (copying source geometry, recording the quad at the modifier's LayerSequence) and calls OnEmitQuad so the subclass can fill colour, UV2, offsets. Multi-layer effects override OnFlush to flush per-layer buffers. Painter order is the single layer axis: every quad — face and duplicates — records its LayerSequence, and the generator sorts the index buffer by it, so stacking follows the order layers appear in Styles. The base class deliberately knows nothing about colour, dilate, softness, offsets, gradients, or any effect-specific parameter. Those live entirely inside the subclass. Common write patterns (solid colour + UV2, per-vertex gradient, offset, expand) are exposed via the static CoverageQuadOps helpers so subclasses share the implementation without sharing the data layout.

Derived Types(3)

Types that inherit from EffectModifier.

C
ExtrudeModifier
Adds a 3D extrude/bevel effect by appending a stack of progressively offset duplicate quads behind the face, shaded across a near→far colour gradient.
C
GlitchModifier
RGB-split glitch bursts: during a burst the glyph doubles into magenta and cyan copies pushed in opposite directions under a crisp original, with horizontal jerks and rare blink-outs. Re-rolls Rate times per phase unit; deterministic per phase, so scrubbing reproduces the same bursts. A colour glyph under the Apply policy gets the jerks, the blink-outs and silhouette fringes; its picture stays in its own layer.
C
PaintLayerModifier
Shared engine for paint layers (fill, stroke, shadow, glow, inner-shadow). Resolves a TextPaint from the parameter, precomputes gradient/texture mapping per styled range, and stamps coverage quads through CoverageQuadOps. Thin subclasses only pick a coverage mode and parse their geometry params — all paint/mapping logic lives here once.
public LayerBlend Blend{ get; set }

How this effect's emitted quads composite with the layers rendered beneath them.

public PaintSpread PaintSpread{ get; set }

Gradient continuation outside the paint's mapping frame, honoured by effects that project a paint; Inherit uses the swatch's value.

public ColorGlyphPolicy ColorGlyphs{ get; set }

Whether the effect decorates colour glyphs — emoji and inline sprites — through their silhouette; Inherit uses the effect's own default (DefaultColorGlyphPolicy). The final parameter slot of every effect, so any parameter added later must follow it.

public int LayerSequence{ get; set }
public bool RendersBehindFill{ get }
public bool ClaimsFill{ get }
protected ColorGlyphPolicy DefaultColorGlyphPolicy{ get }

The colour-glyph policy an unresolved ColorGlyphPolicy.Inherit chain resolves to: skip, unless the effect reads naturally on a silhouette (a shadow, a glow).

protected abstract void OnGlyphEffect()

Called once per glyph during mesh generation. The subclass decides whether the current glyph (UniTextMeshGenerator.currentCluster) needs an effect quad and invokes EnqueueDuplicate if so. A colour glyph (font.IsColor) may be decorated only when UniTextMeshGenerator.HasColorFaceField holds and the range's colour-glyph policy is ColorGlyphPolicy.Apply; its duplicates then sample the silhouette field instead of the bitmap.

protected LayerBlend ResolveBlend(ref ParameterReader reader, in RangeApplyContext context, LayerBlend inherited = LayerBlend.Normal)

Resolves this effect's range blend override against its inherited mode.

protected LayerBlend ResolveBlend(in RangeApplyContext context, LayerBlend inherited = LayerBlend.Normal)

Resolves this effect's range blend override against its inherited mode by the parameter's own slot — for effects that read no other parameter through a reader.

protected PaintSpread ResolveSpread(ref ParameterReader reader, in RangeApplyContext context, PaintSpread inherited = PaintSpread.Clamp)

Resolves this effect's range spread override against its inherited value. Reads the slot before the colour-glyph policy, so call it after every other paint parameter the effect reads.

protected ColorGlyphPolicy ResolveColorGlyphs(ref ParameterReader reader, in RangeApplyContext context)

Resolves the range's colour-glyph policy — Inherit falls through to DefaultColorGlyphPolicy. Reads the final parameter slot, so call it last.

protected ColorGlyphPolicy ResolveColorGlyphs(in RangeApplyContext context)

Resolves the range's colour-glyph policy by the parameter's own slot — for effects that read no other parameter through a reader.

protected void RequestColorGlyphField(int start, int end, float reachEm)

Asks the atlas pipeline for the silhouette fields of the colour glyphs in [start, end) (codepoint indices), reserving at least reachEm of rim beyond the glyph edge. Call from BaseModifier.OnApply for every range whose policy is ColorGlyphPolicy.Apply; the fields exist by the time the mesh is built.

protected abstract void OnEmitQuad(int sourceBaseIdx, int destBaseIdx, int payload)

Writes the actual per-vertex data into a reserved effect-quad slot. The base has already copied geometry (positions, UV0, UV1) from the source face quad and queued the triangle indices; destBaseIdx points at the first of the four duplicate vertices. The subclass writes UniTextMeshGenerator.Colors, UniTextMeshGenerator.Uvs2, and (if needed) re-positions UniTextMeshGenerator.Vertices through CoverageQuadOps helpers.

protected override void OnEnable()
protected override void OnDisable()
protected override void OnDestroy()
protected virtual void ResetOwnRequests()

Resets per-cycle emit state. Subclasses with extra buffers (e.g. multi-layer effects) override and chain to clear their own storage.

protected void EnqueueDuplicate(int sourceBaseIdx, int payload = 0, LayerBlend blend = LayerBlend.Normal)

Queues a duplicate of the given face quad for emission at onMainPassFinalize, recorded at this modifier's LayerSequence — raised by the generator's current UniTextMeshGenerator.sequenceBias, captured here — so it stacks at its layer position inside whichever band the glyph is emitted into.

protected void EnqueueDuplicate(int sourceBaseIdx, int payload, LayerBlend blend, int sequence)

Queues a duplicate at an explicit layer sequence — a claimed fill's output sequence rather than this modifier's own.

protected virtual void OnFlush()

Flushes the pending emit queue. Default implementation processes emits in the order they were enqueued — correct for single-layer effects. Multi-layer effects (e.g. extrude) override and iterate their own per-layer buffers in layer-major order, calling ReserveQuad + OnEmitQuad directly.

protected static int ReserveQuad(UniTextMeshGenerator gen, int sourceBaseIdx, int sequence, LayerBlend blend = LayerBlend.Normal)

Reserves a 4-vertex effect-quad slot: copies positions, UV0 and UV1 from the source quad — or, for a colour face that carries a silhouette field, builds the SDF quad over that field — records the quad at sequence with blend, and advances UniTextMeshGenerator.vertexCount.

Back to API Reference