🧩 Lesson 5.3: Scriptable Renderer Features & Custom Passes

Two Classes

A custom render addition is always two pieces:

The feature is the packaging; the pass is the behaviour. One feature can enqueue several passes if needed. We'll build a simple full-screen colour effect to make the shape concrete — the same skeleton scales up to outlines, blurs, and the mini-project in Lesson 5.5.

The Renderer Feature

The feature creates the pass, points it at a material, and chooses its injection point. Note where it runs — BeforeRenderingPostProcessing, one of the events from Lesson 5.1 — and that we skip non-Game cameras so the Scene view and previews aren't affected:

using UnityEngine;
using UnityEngine.Rendering.Universal;

public class GrayscaleFeature : ScriptableRendererFeature
{
    [SerializeField] Shader shader;   // a full-screen blit shader
    Material material;
    GrayscalePass pass;

    public override void Create()
    {
        if (shader == null) return;
        material = new Material(shader);
        pass = new GrayscalePass(material)
        {
            // WHERE in the frame this pass runs:
            renderPassEvent = RenderPassEvent.BeforeRenderingPostProcessing
        };
    }

    public override void AddRenderPasses(ScriptableRenderer renderer,
        ref RenderingData renderingData)
    {
        if (pass == null) return;
        // Only affect the actual game camera.
        if (renderingData.cameraData.cameraType == CameraType.Game)
            renderer.EnqueuePass(pass);
    }

    protected override void Dispose(bool disposing)
    {
        if (Application.isPlaying) Destroy(material);
        else DestroyImmediate(material);
    }
}

Create() runs when the feature is loaded or its settings change; AddRenderPasses() runs every frame, per camera, and EnqueuePass schedules our pass into that camera's frame. Dispose cleans up the material we newed — features are long-lived, so leaking a material here is a real bug.

RenderGraph: A Shift

Before diving into the pass, one important context. In Unity 6 / URP 17, custom passes are written with the RenderGraph API. Instead of issuing commands into a CommandBuffer imperatively (the old Execute(context, ref renderingData) method), you declare what the pass reads and writes, and the render graph figures out allocation, ordering, and which resources can be reused or culled. It's more declarative — and it's the path Unity is standardising on.

The Pass: RecordRenderGraph

The pass overrides one method. It fetches the frame's resources from a ContextContainer, grabs the camera's colour texture, creates a temporary destination, blits the source through our material into it, and swaps that result back in as the new camera colour:

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering.RenderGraphModule.Util;
using UnityEngine.Rendering.Universal;

public class GrayscalePass : ScriptableRenderPass
{
    const string k_PassName = "GrayscalePass";
    Material material;

    public GrayscalePass(Material material) { this.material = material; }

    public override void RecordRenderGraph(RenderGraph renderGraph,
        ContextContainer frameData)
    {
        // Frame resources for THIS camera.
        var resourceData = frameData.Get<UniversalResourceData>();
        if (resourceData.isActiveTargetBackBuffer) return;   // can't sample the backbuffer

        TextureHandle source = resourceData.activeColorTexture;

        // A temp texture the same shape as the camera colour.
        var desc = source.GetDescriptor(renderGraph);
        desc.name = "_GrayscaleTemp";
        desc.depthBufferBits = 0;
        TextureHandle destination = renderGraph.CreateTexture(desc);

        if (!source.IsValid() || !destination.IsValid()) return;

        // Blit source → destination through our material (pass index 0).
        var blit = new RenderGraphUtils.BlitMaterialParameters(source, destination, material, 0);
        renderGraph.AddBlitPass(blit, k_PassName);

        // Make the effect the new camera colour for later passes.
        resourceData.cameraColor = destination;
    }
}

The key objects: UniversalResourceData gives you the frame's textures (camera colour/depth, normals, etc.), and there's a UniversalCameraData for camera info. A TextureHandle is a declaration of a texture, not the texture itself — the graph resolves it. AddBlitPass records a full-screen blit through the material. Setting resourceData.cameraColor = destination tells everything downstream to use our processed result.

Registering the Feature

A feature does nothing until it's added to the renderer:

1. Find your URP Renderer asset (Project Settings ▸ Graphics points to the URP asset; the URP asset points to a Renderer). Select the Universal Renderer Data asset.
2. In its Inspector, click Add Renderer Feature and choose Grayscale Feature.
3. Assign the full-screen blit Shader to the feature's shader slot.
4. Enter Play — the game view renders in grayscale; the Scene view stays coloured (we filtered to CameraType.Game).

The material's shader is a full-screen blit shader (it samples _BlitTexture over a full-screen triangle and outputs the modified colour). You'll write exactly that shader — and a more interesting effect than grayscale — in the Lesson 5.5 mini-project; here the focus is the feature/pass plumbing that delivers it.

Where It Injects

Tying it back to the frame from Lesson 5.1 — the feature slots a new pass into the ordered event list at the point you chose:

Hands-on Challenge

Summary

🚀 What's Next?

Passes work on images the GPU already drew. Sometimes you want the GPU to compute something arbitrary — a simulation, a procedural texture — outside the draw pipeline entirely. In Lesson 5.4: Compute Shaders we do exactly that, and capture the GPU's output directly.