//
Scriptable Render Pipeline fundamentals
Unity’s Scriptable Render Pipeline (SRP) is a feature that allows you to control rendering
via C# scripts
. SRP is the technology that underpins the Universal Render Pipeline (URP) and the High Definition Render Pipeline (HDRP).
Scriptable Render Pipeline introduction
This page explains how Unity’s Scriptable Render Pipeline (SRP) works, and introduces some key concepts and terminology. 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.
The Scriptable Render Pipeline is a thin API layer that lets you schedule and configure rendering
commands using C# scripts
. Unity passes these commands to its low-level graphics architecture, which then sends instructions to the graphics API.
URP and HDRP are built on top of SRP. You can also create your own custom render pipeline on top of SRP.
Render Pipeline Instance and Render Pipeline Asset
Every render pipeline based on SRP has two key customized elements:
- A Render Pipeline Instance. This is an instance of a class defines the functionality of your render pipeline. Its script inherits from RenderPipeline, and overrides its
Render()
method. - A Render Pipeline Asset. This is an asset in your Unity Project that stores data about which Render Pipeline Instance to use, and how to configure it. Its script inherits from RenderPipelineAsset and overrides its
CreatePipeline()
method.
For more information on these elements, and instructions on how to create them in a custom render pipeline, see Creating a Render Pipeline Asset and a Render Pipeline Instance.
ScriptableRenderContext
ScriptableRenderContext
is a class that acts as an interface between the custom C# code in the render pipeline and Unity’s low-level graphics code.
Use the ScriptableRenderContext API to schedule and execute rendering commands. For information, see Scheduling and executing rendering commands in the Scriptable Render Pipeline.
Entry points and callbacks
When working with SRP, use these to make Unity call your C# code at specific times.
- RenderPipeline.Render is the main entry point to the SRP. Unity calls this method automatically. If you are writing a custom render pipeline, this is where you begin to write your code.
- The RenderPipelineManager class has the following events that you can subscribe to, so that you can execute custom code at specific points in the render loop:
//
Scheduling and executing rendering commands in the Scriptable Render Pipeline
This page explains how to schedule and execute rendering
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# 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 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 CommandBuffer.
using UnityEngine;
using UnityEngine.Rendering;
public class ExampleRenderPipeline : RenderPipeline
{
public ExampleRenderPipeline() {
}
protected override 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.red);
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.
//