Sprite Shaders Animated — 2D

Try 120+ basic effects

First Steps 🚀

1. Import the package

   Drag the .unitypackage into your project. Everything lives under Assets/AnimatedSprite/.

2. Add the component

   Select a SpriteRenderer, click Add Component → Animated Sprite Shader. The correct shader variant is auto-assigned based on your render pipeline.

3. Turn on effects

   Open any category section, tick an effect, and tweak its sliders. That's it — no materials to create, no prefabs to set up.

Render Pipelines ⚙

Every shader variant ships for all three pipelines. Pick the right one and you're good to go. Open Master Setup (Window → Animated Sprite → Master Setup) to set your active pipeline — it patches all .shader files with the correct #define and configures the batching strategy.

All 17 Shader Variants

All 128 Effects ✦

Every effect listed below with a short description of what it does and what it's best used for. The colored dot next to each name shows its performance class: ● lightweight ● moderate ● heavy.

Inspector 🔧

The custom inspector auto-generates UI for all 128 effects from the central registry. No manual wiring — if it's in the registry, it shows up.

Outline Modes & SDF ◻

All outline and edge effects share a configurable sampling mode. Pick the one that fits your quality/performance needs.

SDF Baking

Click Bake SDF Texture in the Edge Effects section to generate a float-precision signed distance field from your sprite. The bake uses the Jump Flood Algorithm and produces a 32-bit float .exr texture — 0.5 = sprite edge, above 0.5 = inside, below 0.5 = outside.

Tools 🛠

Quick actions right from the inspector — no digging through menus.

Effect Masks 🎭

Assign up to 4 grayscale textures as mask channels (R, G, B, A). They auto-pack into a single RGBA texture. Each effect can target a specific channel through the colored buttons below its parameters.

Global Settings 🌐

Performance ⚡

Every effect has a performance class shown as a colored dot in the inspector.

Sampler Packing

20 effect textures share 8 samplers to stay within mobile/DX11/OpenGL limits. Effects with similar sampling needs (linear clamp vs. linear repeat) are grouped onto shared samplers. You don't need to configure anything — it's automatic.

Animation System ♫

Every property is animatable through Unity's Animation window. The built-in keyframe editor generates curves without touching the timeline manually.

Keyframe Editor 🎹

Click ♫ next to any float, color, or vector property to open it.

Animation Browser 📂

In the Tools section — shows all clips in the Animator Controller, lists animated shader properties with their value ranges. Click Open to jump to that clip in the Animation window.

C# Scripting API { }

Every effect can be enabled, configured, and animated from code. All public fields on AnimatedSpriteShader are yours to set.

Enable / Disable

var mgr = GetComponent<AnimatedSpriteShader>();

mgr.outlineEnabled = true;
mgr.outlineColor = Color.cyan;
mgr.outlineSize = 0.02f;

mgr.dissolveEnabled = true;
mgr.dissolveAmount = 0.5f;

mgr.MarkDirty();  // always call after changing values from code

Switch Shader Variant

mgr.ChangeShaderVariant(AnimatedSpriteShader.ShaderVariant.Lit2D_URP);

Incremental Push

// Mark only what changed — avoids pushing all 128 effects every frame
mgr.MarkEffectDirty(EffectId.Dissolve);
mgr.MarkGlobalsDirty();
mgr.IncrementalPush();  // pushes only dirty groups to the GPU

Combo Examples 🎨

mgr.frozenEnabled = true;
mgr.frozenContrast = 2f;
mgr.frozenHighlight = 1.5f;
mgr.outlineEnabled = true;
mgr.outlineColor = new Color(0.5f, 0.85f, 1f);
mgr.outlineSize = 0.015f;
mgr.hexDissolveEnabled = true;
mgr.hexDissolveAmount = 0f; // animate 0→1 to shatter
mgr.MarkDirty();

mgr.holographicCardEnabled = true;
mgr.shineEnabled = true;
mgr.shineWidth = 0.15f;
mgr.shineGlow = 2f;
mgr.outlineEnabled = true;
mgr.outlineColor = Color.white;
mgr.outlineSize = 0.008f;
mgr.MarkDirty();

mgr.hitEffectEnabled = true;
mgr.hitEffectColor = Color.white;
mgr.hitEffectBlend = 1f;
mgr.wiggleEnabled = true;
mgr.wiggleAmount = 0.05f;
mgr.wiggleFrequency = 25f;
mgr.MarkDirty();
// Then lerp hitEffectBlend and wiggleAmount back to 0 over ~0.15s

Effect Presets 💾

Save any sprite's complete effect setup as a ScriptableObject and load it onto other sprites. The preset stores every enabled effect plus all its parameters.

var preset = Resources.Load<AnimSpriteEffectPreset>("MyPreset");
preset.ApplyTo(mgr);
mgr.MarkDirty();

Architecture 🧠

Understanding how the pieces fit together helps when extending the system or debugging edge cases.

Shader Internals ⚙

The fragment shader processes effects in a strict order inside the dispatch groups:

// 1. UV effects (wave, twist, distort, pixelate, scroll…)
uv = ApplyUVGroup(uv, time, worldPos);

// 2. Sample main texture + edge cleanup
half4 col = STEX(_MainTex, sampler_MainTex, uv);

// 3. Filter effects (sharpen, blur, flipbook blend…)
col = ApplyFilterGroup(col, uv, time);

// 4. Color effects (tint, bloom, hue, posterize…)
col = ApplyColorGroup(col, uv, time, worldPos);

// 5. Extended color (gradient, radial gradient, color ramp…)
col = ApplyColorExtGroup(col, uv, time);

// 6. Edge effects (outline, glow, shadow, rim…)
col = ApplyEdgeGroup(col, uv, time, masks);

// 7. Dissolve effects (fade, wipe, dissolve…)
col = ApplyDissolveGroup(col, uv, time, masks);

// 8. VFX effects (hologram, glitch, shine, flame…)
col = ApplyVFXGroup(col, uv, time, masks);

// 9. Gameplay effects (health tint, x-ray, trails…)
col = ApplyGameGroup(col, uv, time, masks);

Each effect block checks its _En float, optionally samples the effect mask, computes the effect, and composites via lerp or alpha blending. The order within each group is configurable through Master Setup.

SDF Pipeline ◈

The SDF system uses a signed distance field for outline and glow rendering. Here's how it works end-to-end.

Bake Process (C#)

BakeOutlineSDF() reads the sprite's texture rect, pads it by a configurable amount (default 16px), and computes inner + outer distance fields using the Jump Flood Algorithm. The result is a signed distance normalized into [0, 1]:

signedDist = isSolid ? -innerDist : outerDist;
normalized = 0.5 - signedDist / (2 * spread);

Output is a 32-bit float RFloat texture saved as .exr — smooth gradients without banding. The spread value is stored on the component and pushed to the shader as _OutlineSDFSpread.

Outline Band Extraction (Shader)

The outline is carved from two one-sided smoothsteps to prevent overlap at small widths:

sdfWidth = sizePx / (spread * 2);
outerEdge = 0.5 - sdfWidth;
outer = smoothstep(outerEdge - softness, outerEdge, sdf);
inner = smoothstep(0.5, 0.5 + softness, sdf);
outline = outer * (1.0 - inner);

This avoids the classic "surge at zero width" bug where symmetric smoothsteps overlap at their tails.

Adding a Custom Effect ➕

The system is designed to be extended. Add your own effects following this pattern:

1. Write the Shader Code

   Add your effect function in AllInOneEffects.hlsl inside a #ifdef YOUR_KEYWORD block. Declare properties in AllInOneProperties.hlsl (both CBUFFER paths) and the keyword in AllInOneKeywords.hlsl.

2. Register in EffectRegistry

   Add a new entry to the All array using M() or MG(). Define EffectId, name, keyword, enable field, category, group, and parameters.

3. Add C# Fields

   Add matching public fields to AnimatedSpriteShader.cs — the enable bool plus any parameters. Field names must match the registry exactly.

4. Wire up Push()

   In Push(), add the keyword toggle and property block calls. Follow the pattern of existing effects.

M(EffectId.MyEffect, "My Effect", "_MYEFFECT_ON",
    "myEffectEnabled", "_MyEffect_En", EffectCategory.Special,
    "myEffectMaskCh", "_MyEffectMaskCh",
    F("myEffectAmount", "_MyEffectAmount", "Amount", 0, 1, "0.5"),
    C("myEffectColor", "_MyEffectColor", "Color")),

Batching & MaterialPropertyBlock 📊

One shared material per shader variant. Per-instance values go through MaterialPropertyBlock — no batch breaks for parameter changes.

Batches together: same variant + same enabled effects (same keyword set).

Doesn't break batches: different colors, amounts, intensities, textures in the property block.

Breaks batches: different variants or different sets of enabled effects.

Support & Effect Requests 💬

Got an idea for a new effect? Found a bug? Need help?

🎯 Requesting a New Effect

We actively build effects based on community requests. When describing what you want, it helps to include:

Popular requests get prioritized in upcoming updates.

FAQ ❓

My sprite turns pink / magenta

Shader variant doesn't match your render pipeline. Switch to the right one in the dropdown, or use Master Setup → Pipeline Migration to batch-fix all sprites.

Outline / glow bleeds into atlas neighbors

Click Atlas Setup in Tools. It writes UV bounds so edge effects stay inside your sprite's region.

SDF outline is clipped at sprite edges

Set your sprite's Mesh Type to Full Rect in the import settings. Tight meshes clip anything outside the silhouette.

SDF outline looks wrong after re-importing a sprite

Re-bake the SDF. The distance field is computed from the texture — if the sprite changes, the SDF needs regenerating.

Effects don't update in play mode

Call MarkDirty() after changing values from code. In the editor, changes push automatically.

Works with Spine / 2D Animation?

Yes. Color effects work on skeletal sprites out of the box. Edge effects apply per sub-sprite mesh.

How many effects can I stack?

No hard limit. Unity 2021.2+ supports 65,534 local keywords. Stack as many as you want.

Works with UI / Canvas?

Yes — use the GUI, GUI Additive, GUI Premultiply, or Screen Space Overlay variants.

Mobile performance?

Disabled effects = zero cost. On mobile, stick to green-dot (lightweight) effects. Use Bake PNG for complex setups — renders everything into a flat texture at export time.

How does batching work?

One shared material per variant. Per-instance data goes through MaterialPropertyBlock. Sprites with the same variant and same enabled effects batch together. Different parameter values (colors, amounts) don't break batches.