🔥 Lesson 8.4: Building a Dissolve Shader (Mini-Project)

How a Dissolve Works

The trick is disarmingly simple. Every pixel gets a random-ish value from a noise texture (0 to 1). You then pick a threshold: any pixel whose noise value is below the threshold gets erased. Slide the threshold from 0 to 1 over time and the object vanishes in a natural, blotchy pattern instead of a clean wipe.

Two ingredients turn that into a convincing effect:

• Alpha clipping — the shader discards (doesn't draw) any pixel below the threshold, punching real holes in the mesh.
• An emissive edge — the thin band of pixels right at the threshold glows hot, so it looks like the object is burning away rather than turning invisible.

Graph Setup & Alpha Clipping

Create a URP ▸ Lit Shader Graph called SG_Dissolve. Before wiring anything, turn on alpha clipping or the effect can't remove pixels:

1. Open the Graph Inspector (top-right of the editor) ▸ Graph Settings.
2. Tick Alpha Clipping. This adds an Alpha Clip Threshold input to the Fragment block of the Master Stack.

Then add these Blackboard properties:

• BaseTex (Texture2D) — the object's normal surface texture.
• Dissolve (Float, range 0–1, default 0) — how far along the dissolve is. This is the value your script animates.
• NoiseScale (Float, default 12) — how fine or chunky the dissolve pattern is.
• EdgeWidth (Float, default 0.05) — how thick the glowing edge band is.
• EdgeColor (Color, HDR) — the glow colour; make it HDR so it can be brighter than white and bloom later.

The Dissolve Network

Here is the heart of the mini-project — the dissolve network rebuilt exactly as you'll wire it in Shader Graph:

Reading it left to right:

1. Simple Noise (scaled by NoiseScale) gives each pixel a value 0–1.
2. A Step node compares that noise against Dissolve. Step outputs 1 where noise ≥ Dissolve and 0 below it — a hard cutoff. Feed the result (inverted as needed) into Alpha Clip Threshold so low pixels get discarded.
3. As Dissolve rises toward 1, more pixels fall below the cutoff and disappear.

The Glowing Edge

A dissolve without a burning edge looks like a bug, not an effect. The edge is just a second threshold offset slightly from the first, so it isolates the thin band of pixels that are about to disappear:

• Take the same noise, and build a band: pixels where noise is between Dissolve and Dissolve + EdgeWidth. A second Step (or a Smoothstep for a softer band) isolates them.
• Multiply that band by the HDR EdgeColor so only the band glows.
• Feed the result into Emission. Because the colour is HDR (values above 1), it'll bloom brightly once you add post-processing in the next module.

Now the leading edge of the dissolve burns hot orange while everything behind it is already gone. That single extra branch is the difference between "cheap" and "cool."

💡 HDR + Bloom = fire. An emissive edge with an HDR colour looks merely bright on its own. Add a URP Bloom post-process (Lesson 9.3) and that same edge blooms into a glowing, fiery rim. Author the glow now; it pays off later.

Animating It from Code

The shader can dissolve to any fixed amount, but the effect is the animation. Give Dissolve the Reference name _Dissolve in the Graph Inspector, then drive it from a script. Note we use a MaterialPropertyBlock so we don't create a leaked material instance per object:

using System.Collections;
using UnityEngine;

[RequireComponent(typeof(Renderer))]
public class DissolveController : MonoBehaviour
{
    [SerializeField] float duration = 1.5f;   // seconds to fully dissolve
    [SerializeField] bool destroyWhenDone = true;

    static readonly int DissolveID = Shader.PropertyToID("_Dissolve");

    Renderer rend;
    MaterialPropertyBlock mpb;

    void Awake()
    {
        rend = GetComponent<Renderer>();
        mpb = new MaterialPropertyBlock();
    }

    // Call this from anywhere — e.g. when an enemy dies
    public void Dissolve()
    {
        StopAllCoroutines();
        StartCoroutine(DissolveRoutine());
    }

    IEnumerator DissolveRoutine()
    {
        float t = 0f;
        while (t < duration)
        {
            t += Time.deltaTime;
            float amount = Mathf.Clamp01(t / duration);   // 0 -> 1

            rend.GetPropertyBlock(mpb);
            mpb.SetFloat(DissolveID, amount);
            rend.SetPropertyBlock(mpb);

            yield return null;
        }

        if (destroyWhenDone)
            Destroy(gameObject);
    }
}

Attach this to any object using the dissolve material, and call Dissolve() from your death logic. Over duration seconds it ramps _Dissolve from 0 to 1 and the object burns away, then removes itself.

Mini-Project: Disintegrate on Death

Tie the module together. Reuse the health/damage interface from Module 7: when an enemy's health hits zero, instead of a plain Destroy, trigger the dissolve.

using UnityEngine;

// Assumes an IDamageable / health system from Module 7 raises OnDied.
[RequireComponent(typeof(DissolveController))]
public class EnemyDeathDissolve : MonoBehaviour
{
    DissolveController dissolver;

    void Awake() => dissolver = GetComponent<DissolveController>();

    // Hook this to your health component's death event
    public void OnDied()
    {
        // stop AI, disable colliders, etc. here if needed
        dissolver.Dissolve();   // burns away, then self-destructs
    }
}

Wire OnDied to the health event (a UnityEvent in the Inspector, or a C# event from Module 2). Now shooting an enemy to zero HP makes it disintegrate with a glowing edge instead of popping out of existence — a small change that makes combat feel dramatically more polished.

Hands-on Challenge

Summary

🚀 What's Next?

Module 8 is done — you can light a scene, bake it, and author your own shaders. Module 9 turns up the spectacle. In Lesson 9.1: Particle Systems (Shuriken) you'll add smoke, sparks, and fire with Unity's classic particle system — the perfect companion to the dissolve you just built.