Scheduling and executing rendering commands in the Scriptable Render Pipeline

In the Scriptable Render Pipeline (SRP), you use C# scripts to configure and schedule rendering commands. You then tell Unity’s low-level graphics architecture to execute them, which sends instructions to the graphics API.

The main way of doing this is by using the Scriptable Render Context, but you can also execute Command Buffers immediately.

Using the Scriptable Render Context

The Scriptable Render Context acts as an interface between your C# code and Unity’s low-level graphics code. In SRP, rendering works using delayed execution; you use the Scriptable Render Context to build up a list of rendering commands, and then you tell Unity to execute them. Unity’s low-level graphics architecture then sends instructions to the graphics API.

To schedule rendering commands, you can: * Pass CommandBuffers to the Scriptable Render Context, using ScriptableRenderContext.ExecuteCommandBuffer() * Make direct API calls ot the Scriptable Render Context, such as ScriptableRenderContext.Cull() or ScriptableRenderContext.DrawRenderers()

To tell Unity to perform the commands that you have scheduled, call ScriptableRenderContext.Submit(). Note that it does not matter whether you used a Command Buffer to schedule the command, or whether you scheduled the command by calling an API; Unity schedules all rendering commands on the Scriptable Render Context in the same way, and does not execute any of them until you call Submit().

This example code demonstrates how to schedule and perform a command to clear the current render target, using a Command Buffer.

using UnityEngine;
using UnityEngine.Rendering;

public class ExampleRenderPipelineInstance : RenderPipeline
{
        public ExampleRenderPipelineInstance() {
        }

    protected void Render(ScriptableRenderContext context, Camera[] cameras) {
        // Create and schedule a command to clear the current render target
        var cmd = new CommandBuffer();
        cmd.ClearRenderTarget(true, true, Color.black);
        context.ExecuteCommandBuffer(cmd);
        cmd.Release();

         // Tell the Scriptable Render Context to tell the graphics API to perform the scheduled commands
        context.Submit();
    }
}

Executing Command Buffers immediately

You can execute Command Buffers immediately without using the Scriptable Render Context, by calling Graphics.ExecuteCommandBuffer(). Calls to this API take place outside of the render pipeline.

Additional information

For more information on commands that you can schedule using Command Buffers, see Command Buffers API documentation.