Unity SRP：从 Camera 到 GPU 理解渲染管线架构

找到物体
→ 画出来

Culling
↓
Shadow Map
↓
Depth Prepass
↓
Opaque
↓
Lighting
↓
SSAO / SSR / Decal / ...
↓
Transparent
↓
Post Processing
↓
Final Output

先画 Shadow
还是先做 Depth Prepass？

Opaque 用什么规则筛选？

Transparent 怎样排序？

什么时候切换 Render Target？

什么时候 Dispatch Compute Shader？

什么时候做 Post Process？

Cull
↓
只筛 Opaque
↓
Front-to-Back 排序
↓
Draw

同一个 CullingResults
↓
只筛 Transparent
↓
Back-to-Front 排序
↓
Draw

RenderPipelineAsset
RenderPipeline

using UnityEngine;
using UnityEngine.Rendering;

[CreateAssetMenu(menuName = "Rendering/Tiny Render Pipeline")]
public sealed class TinyRenderPipelineAsset : RenderPipelineAsset
{
    [SerializeField]
    private Color clearColor = new(0.05f, 0.05f, 0.05f);

    protected override RenderPipeline CreatePipeline()
    {
        return new TinyRenderPipeline(clearColor);
    }
}

CreatePipeline()

Shadow Distance
MSAA
HDR
Render Scale
Lighting Quality
Post Processing Settings
...

RenderPipeline

protected override void Render(
    ScriptableRenderContext context,
    List<Camera> cameras)

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

public sealed class TinyRenderPipeline : RenderPipeline
{
    private readonly Color clearColor;

    public TinyRenderPipeline(Color clearColor)
    {
        this.clearColor = clearColor;
    }

    protected override void Render(
        ScriptableRenderContext context,
        List<Camera> cameras)
    {
        foreach (Camera camera in cameras)
        {
            RenderCamera(context, camera);
        }
    }

    private void RenderCamera(
        ScriptableRenderContext context,
        Camera camera)
    {
        // 后面逐步实现
    }
}

保存
序列化
Inspector 编辑
不同质量等级配置
创建 Runtime Instance

持有运行时资源
执行 Render Loop
管理临时状态
创建 Buffer
执行每帧逻辑

private void RenderCamera(
    ScriptableRenderContext context,
    Camera camera)
{
    context.SetupCameraProperties(camera);

    CommandBuffer cmd =
        CommandBufferPool.Get("Tiny SRP");

    cmd.ClearRenderTarget(
        clearDepth: true,
        clearColor: true,
        backgroundColor: clearColor
    );

    context.ExecuteCommandBuffer(cmd);

    context.Submit();

    CommandBufferPool.Release(cmd);
}

Camera
├─ View Matrix
├─ Projection Matrix
├─ Frustum
├─ Near / Far
├─ Culling Mask
└─ Rendering State

SetRenderTarget
ClearRenderTarget
SetGlobalTexture
DrawMesh
DrawRendererList
DispatchCompute
Blit
...

“之后请执行这些事情。”

C# 调用 API
↓
Schedule Commands
↓
ScriptableRenderContext
↓
Submit
↓
Unity Graphics Backend
↓
Graphics API / GPU

Scene 中所有对象

Frustum Culling

Opaque Pass
只画不透明物体

Transparent Pass
只画透明物体

Shadow Pass
只画 Shadow Caster

Depth Pass
只需要能参与 Depth 的 Shader Pass

var filtering = new FilteringSettings(
    RenderQueueRange.opaque
);

var filtering = new FilteringSettings(
    RenderQueueRange.transparent
);

GameObject Layer
Rendering Layer
Render Queue
Motion Vector 状态
...

CullingResults
↓
FilteringSettings
↓
当前 Pass 真正关心的对象

var sorting = new SortingSettings(camera)
{
    criteria = SortingCriteria.CommonOpaque
};

criteria = SortingCriteria.CommonTransparent;

正确性
+
Overdraw
+
State Change
+
性能

Sorting
Shader Pass
Per-object Data
Instancing
Override Material / Shader
...

static readonly ShaderTagId ShaderTag =
    new("SRPDefaultUnlit");

var drawing = new DrawingSettings(
    ShaderTag,
    sorting
)
{
    enableInstancing = true
};

ShaderTagId

context.DrawRenderers(
    cullingResults,
    ref drawingSettings,
    ref filteringSettings
);

private static readonly ShaderTagId ShaderTag =
    new("SRPDefaultUnlit");

private static void DrawObjects(
    ScriptableRenderContext context,
    CommandBuffer cmd,
    Camera camera,
    CullingResults cullingResults,
    bool transparent)
{
    var sortingSettings = new SortingSettings(camera)
    {
        criteria = transparent
            ? SortingCriteria.CommonTransparent
            : SortingCriteria.CommonOpaque
    };

    var drawingSettings = new DrawingSettings(
        ShaderTag,
        sortingSettings
    )
    {
        enableInstancing = true
    };

    var filteringSettings = new FilteringSettings(
        transparent
            ? RenderQueueRange.transparent
            : RenderQueueRange.opaque
    );

    var rendererListParams = new RendererListParams(
        cullingResults,
        drawingSettings,
        filteringSettings
    );

    RendererList rendererList =
        context.CreateRendererList(ref rendererListParams);

    cmd.DrawRendererList(rendererList);

    context.ExecuteCommandBuffer(cmd);
    cmd.Clear();
}

foreach (Renderer renderer in scene)
{
    renderer.Draw();
}

Camera
↓
Cull
↓
Opaque
↓
Skybox
↓
Transparent
↓
Submit

RendererList skybox =
    context.CreateSkyboxRendererList(camera);

cmd.DrawRendererList(skybox);

context.ExecuteCommandBuffer(cmd);
cmd.Clear();

private void RenderCamera(
    ScriptableRenderContext context,
    Camera camera)
{
    if (!camera.TryGetCullingParameters(
            out var cullingParameters))
    {
        return;
    }

    CullingResults cullingResults =
        context.Cull(ref cullingParameters);

    context.SetupCameraProperties(camera);

    CommandBuffer cmd =
        CommandBufferPool.Get(camera.name);

    cmd.ClearRenderTarget(
        clearDepth: true,
        clearColor: true,
        backgroundColor: clearColor
    );

    context.ExecuteCommandBuffer(cmd);
    cmd.Clear();

    // 1. Opaque
    DrawObjects(
        context,
        cmd,
        camera,
        cullingResults,
        transparent: false
    );

    // 2. Skybox
    RendererList skybox =
        context.CreateSkyboxRendererList(camera);

    cmd.DrawRendererList(skybox);

    context.ExecuteCommandBuffer(cmd);
    cmd.Clear();

    // 3. Transparent
    DrawObjects(
        context,
        cmd,
        camera,
        cullingResults,
        transparent: true
    );

    context.Submit();

    CommandBufferPool.Release(cmd);
}

Lighting
Shadow
Depth Texture
Reflection Probe
Post Processing
Editor Gizmo
XR
Camera Stack
MSAA
HDR
...

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;

public sealed class TinyRenderPipeline : RenderPipeline
{
    private static readonly ShaderTagId ShaderTag =
        new("SRPDefaultUnlit");

    private readonly Color clearColor;

    public TinyRenderPipeline(Color clearColor)
    {
        this.clearColor = clearColor;
    }

    protected override void Render(
        ScriptableRenderContext context,
        List<Camera> cameras)
    {
        BeginContextRendering(context, cameras);

        foreach (Camera camera in cameras)
        {
            BeginCameraRendering(context, camera);

            RenderCamera(context, camera);

            EndCameraRendering(context, camera);
        }

        EndContextRendering(context, cameras);
    }

    private void RenderCamera(
        ScriptableRenderContext context,
        Camera camera)
    {
        if (!camera.TryGetCullingParameters(
                out var cullingParameters))
        {
            return;
        }

        CullingResults cullingResults =
            context.Cull(ref cullingParameters);

        context.SetupCameraProperties(camera);

        CommandBuffer cmd =
            CommandBufferPool.Get(camera.name);

        cmd.ClearRenderTarget(
            clearDepth: true,
            clearColor: true,
            backgroundColor: clearColor
        );

        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();

        DrawObjects(
            context,
            cmd,
            camera,
            cullingResults,
            transparent: false
        );

        RendererList skybox =
            context.CreateSkyboxRendererList(camera);

        cmd.DrawRendererList(skybox);

        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();

        DrawObjects(
            context,
            cmd,
            camera,
            cullingResults,
            transparent: true
        );

        context.Submit();

        CommandBufferPool.Release(cmd);
    }

    private static void DrawObjects(
        ScriptableRenderContext context,
        CommandBuffer cmd,
        Camera camera,
        CullingResults cullingResults,
        bool transparent)
    {
        var sortingSettings = new SortingSettings(camera)
        {
            criteria = transparent
                ? SortingCriteria.CommonTransparent
                : SortingCriteria.CommonOpaque
        };

        var drawingSettings = new DrawingSettings(
            ShaderTag,
            sortingSettings
        )
        {
            enableInstancing = true
        };

        var filteringSettings = new FilteringSettings(
            transparent
                ? RenderQueueRange.transparent
                : RenderQueueRange.opaque
        );

        var rendererListParams = new RendererListParams(
            cullingResults,
            drawingSettings,
            filteringSettings
        );

        RendererList rendererList =
            context.CreateRendererList(ref rendererListParams);

        cmd.DrawRendererList(rendererList);

        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();
    }
}

BeginContextRendering(...)
BeginCameraRendering(...)
EndCameraRendering(...)
EndContextRendering(...)

context.Cull(...)
context.SetupCameraProperties(...)
context.CreateRendererList(...)
context.ExecuteCommandBuffer(...)
context.Submit()

GPU

CommandBuffer

一张 Render Texture

Cull
创建 RendererList
建立 Camera 状态
调度 CommandBuffer
创建 Shadow / Skybox RendererList
最终 Submit

context.Cull(...)
context.CreateRendererList(...)
context.Submit()

cmd.ClearRenderTarget(...);
cmd.SetGlobalTexture(...);
cmd.DrawMesh(...);
cmd.DrawRendererList(...);
cmd.DispatchCompute(...);

context.ExecuteCommandBuffer(cmd);

cmd.DrawMesh(...)

cmd.DrawRendererList(...)

foreach (Renderer renderer in scene)
{
    ...
}

Scene
↓
Cull
↓
Visible Renderers
↓
Filtering / Drawing / Sorting
↓
RendererList
↓
Draw

private static readonly ShaderTagId ShaderTag =
    new("SRPDefaultUnlit");

SubShader
{
    Pass
    {
        Tags { "LightMode" = "MyForward" }
    }

    Pass
    {
        Tags { "LightMode" = "ShadowCaster" }
    }

    Pass
    {
        Tags { "LightMode" = "DepthOnly" }
    }
}

TinyForward
TinyDepth
TinyShadowCaster

new ShaderTagId("TinyForward");

Tags { "LightMode" = "TinyForward" }

UniversalForward
UniversalGBuffer
ShadowCaster
DepthOnly
SRPDefaultUnlit

Shader "TinySRP/Unlit"
{
    Properties
    {
        _BaseColor ("Base Color", Color) = (1, 1, 1, 1)
    }

    SubShader
    {
        Tags
        {
            "Queue" = "Geometry"
        }

        Pass
        {
            Tags
            {
                "LightMode" = "SRPDefaultUnlit"
            }

            HLSLPROGRAM

            #pragma vertex Vert
            #pragma fragment Frag

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl"

            struct Attributes
            {
                float3 positionOS : POSITION;
            };

            struct Varyings
            {
                float4 positionCS : SV_POSITION;
            };

            CBUFFER_START(UnityPerMaterial)
                float4 _BaseColor;
            CBUFFER_END

            Varyings Vert(Attributes input)
            {
                Varyings output;
                output.positionCS =
                    TransformObjectToHClip(input.positionOS);
                return output;
            }

            half4 Frag(Varyings input) : SV_Target
            {
                return _BaseColor;
            }

            ENDHLSL
        }
    }
}

Object Space Position
↓
Clip Space Position
↓
输出 Base Color

C# Render Pipeline
    ↓
ShaderTagId("SRPDefaultUnlit")

Shader
    ↓
LightMode = "SRPDefaultUnlit"

两边匹配
    ↓
RendererList 可以选择这个 Shader Pass

Pass
{
    Tags { "LightMode" = "ShadowCaster" }

    HLSLPROGRAM
    ...
    ENDHLSL
}

Shadow Pass
Depth Pass
Opaque Pass
SSAO Pass
Transparent Pass
Post Process Pass

Draw
Draw
Draw

Color Buffer
Depth Buffer

Scene
↓
Screen

Geometry
↓
GBuffer

GBuffer + Lights
↓
Lighting

Depth + Normal
↓
AO Texture
↓
Lighting / Composite

Scene Color
↓
Threshold
↓
Downsample
↓
Blur
↓
Upsample
↓
Composite

Cull
↓
Opaque
↓
Skybox
↓
Transparent

Culling

↓
Shadow Culling
↓
Shadow Maps

↓
Depth Prepass
↓
Depth Pyramid

↓
GBuffer / Forward Opaque
↓
Decals
↓
Lighting
↓
SSAO
↓
SSR
↓
Volumetric Lighting

↓
Transparent
↓
Distortion

↓
TAA / Upscaler
↓
Bloom
↓
Depth of Field
↓
Tonemapping

↓
UI
↓
Final Output

Compute Pass
Copy Pass
Ray Tracing Pass
Async Compute
GPU-driven Culling

Camera
↓
Cull
↓
Visible Objects
↓
Draw to Camera Target

Light View
↓
Shadow Culling
↓
Shadow Casters
↓
Draw Depth to Shadow Map

CreateShadowRendererList(...)

Visible Lights
Main Light
Additional Lights
Light Culling
Shadow Data
Reflection Probe
Light Probe
Shader Constant Buffer
Forward / Deferred

Opaque
Transparent

DrawOpaque();
DrawTransparent();

RenderShadow();
RenderDepth();
RenderOpaque();
RenderSSAO();
RenderSSR();
RenderTransparent();
RenderBloom();
RenderPostProcess();

AO Texture

SSAO → Lighting

Create
Use
Release

Depth
↓
SSAO
↓
Composite

Shadow Map
Environment Processing

Pass A
↓
生成 TempTexture

创建 TempA
↓
执行 Pass A
↓
切 RenderTarget
↓
执行 Pass B
↓
释放 TempA
↓
创建 TempB
...

Pass A:
Write Texture A

Pass B:
Read Texture A
Write Texture B

Pass C:
Read Texture B
Write Camera Color

Resource Lifetime Analysis
Transient Resource Reuse
Pass Culling
Pass Scheduling
Debug Visualization

TextureHandle
RasterGraphContext
IRasterRenderGraphBuilder
Pass Culling
Resource Aliasing

Scriptable Render Pipeline Core

com.unity.render-pipelines.core

Render Graph
RTHandle
Volume Framework
Core Utilities
Shader Library
平台相关辅助
公共渲染工具
...

SRP
= Unity 允许你构建 Scriptable Render Pipeline 的核心机制

SRP Core
= Unity 提供的一组可复用渲染基础设施和工具库

URP
HDRP

SRP 的两个模式开关

UniversalRenderPipeline
ScriptableRenderer
UniversalRenderer
ScriptableRendererFeature
ScriptableRenderPass
URP Lighting
URP Shader Tags
URP Render Graph Frame Data
...

HDRenderPipeline
HDRP Lighting
GBuffer
Volumetrics
Custom Pass
HDRP Shader Pass
Ray Tracing
...

SRP
=
ScriptableRenderer
+
Renderer Feature
+
ScriptableRenderPass

一个具体产品的架构

底层框架本身

RenderPipeline
↓
Render()
↓
ScriptableRenderContext
↓
Cull
↓
RendererList / Commands
↓
Submit

UniversalRenderer
ForwardRenderer
2D Renderer
Renderer Feature

新的 Lighting Model
新的 GBuffer Layout
特殊的 Visibility Pipeline
完全不同的 Shadow Architecture
研究性质 Renderer

Custom SRP

Outline
X-Ray
Object ID
Scanner
特殊 Mask
Fullscreen Effect

URP
↓
Renderer Feature
↓
ScriptableRenderPass


HDRP
↓
Custom Pass

SRP
= 构建 Scriptable Render Pipeline 的基础机制

URP / HDRP
= Unity 基于 SRP 构建的具体 Pipeline

SRP = URP

HDRP 建立在 URP 上

        SRP
       /   \
     URP   HDRP

MeshRenderer
SkinnedMeshRenderer
ParticleSystemRenderer

ScriptableRenderer

Render Pass
= Pipeline 的一个工作阶段

Shader Pass
= Shader 中的一套 GPU Program + Render State

SRP
= 渲染管线机制

SRP Core
= Unity 提供的共享渲染工具包

SRP
= Render Pipeline Architecture

SRP Batcher
= Render State / Draw Submission Optimization

context.Cull(...)

context.Cull()
=
GPU Occlusion Culling

CommandBuffer
= 我记录一系列要执行的图形命令

Render Graph
= 我描述 Pass、Resource 和依赖关系

context.DrawRenderers(...)

Draw Submission
GPU-driven Rendering
Render Graph
Resource Management

Camera
↓
Visibility

Visibility
↓
Selection

Selection
↓
Draw Work

Draw Work
↓
Resources / Render Targets

Passes
↓
Dependencies

Commands
↓
Graphics Backend
↓
GPU

Camera
↓
RenderPipeline.Render()
↓
Cull
↓
CullingResults
↓
Filter + Sort + Drawing Rules
↓
RendererList
↓
CommandBuffer
↓
ScriptableRenderContext
↓
Submit
↓
Graphics API
↓
GPU

ScriptableRenderer
Renderer Feature
ScriptableRenderPass
RecordRenderGraph

Custom Pass
Injection Point

Render Graph

SRP
“整条 Render Pipeline 怎样运行？”

↓


自定义渲染
“怎样往现有 URP / HDRP 中插入自己的工作？”

↓


Render Graph
“越来越多的 Pass 和 Resource 应该怎样组织？”