Scheduling and executing rendering commands in the Scriptable Render Pipeline

This page explains how to schedule and execute renderingThe process of drawing graphics to the screen (or to a render texture). By default, the main camera in Unity renders its view to the screen. More info
See in Glossary commands in the Scriptable Render Pipeline (SRP), either by using CommandBuffers or by making direct API calls to the ScriptableRenderContext. The information on this page is applicable to the Universal Render Pipeline (URP), the High Definition Render Pipeline (HDRP), and custom render pipelines that are based on SRP.

In SRP, you use C# scriptsA piece of code that allows you to create your own Components, trigger game events, modify Component properties over time and respond to user input in any way you like. More info
See in Glossary 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 making API calls to the ScriptableRenderContext, but you can also execute CommandBuffers immediately.

Using the ScriptableRenderContext APIs

In SRP, the ScriptableRenderContext class acts as an interface between the C# render pipeline code and Unity’s low-level graphics code. SRP rendering works using delayed execution; you use the ScriptableRenderContext 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 ScriptableRenderContext, using ScriptableRenderContext.ExecuteCommandBuffer
• Make direct API calls to 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 CommandBuffer to schedule the command, or whether you scheduled the command by calling an API; Unity schedules all rendering commands on the ScriptableRenderContext 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 CommandBuffers immediately

You can execute CommandBuffers immediately without using the ScriptableRenderContext, 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 CommandBuffers, see CommandBuffers API documentation.