Unity SRP核心架构 - 元素码农

发布时间: 2025-03-23 08:58

↑

# Unity SRP核心架构

本文将深入探讨Unity的可编程渲染管线(Scriptable Render Pipeline, SRP)的核心架构设计。通过本文,你将了解SRP的设计理念、核心组件和工作流程,以及如何基于SRP框架开发自定义渲染管线。

## 基础概念

### 什么是SRP

SRP(Scriptable Render Pipeline)是Unity提供的一个可编程渲染管线框架,它允许开发者:

1. 完全控制渲染流程
2. 自定义渲染策略
3. 针对特定平台优化
4. 实现特殊的渲染效果

### 为什么需要SRP

```csharp
// 传统渲染管线的限制
public class TraditionalRenderer : MonoBehaviour
{
    void OnRenderImage(RenderTexture src, RenderTexture dest)
    {
        // 只能在后处理阶段介入
        Graphics.Blit(src, dest);
    }
}
```

传统内置渲染管线的问题:

1. 可定制性有限
2. 性能优化空间小
3. 难以实现特殊效果
4. 跨平台适配困难

## 核心架构

### 架构概览

```csharp
// SRP核心组件示例
public class CustomRenderPipeline : RenderPipeline
{
    private CustomRenderPipelineAsset pipelineAsset;
    private ScriptableRenderer renderer;

public CustomRenderPipeline(CustomRenderPipelineAsset asset)
    {
        pipelineAsset = asset;
        renderer = new CustomRenderer(asset.settings);
    }

protected override void Render(
        ScriptableRenderContext context,
        Camera[] cameras)
    {
        // 自定义渲染流程
        foreach (Camera camera in cameras)
        {
            renderer.Render(context, camera);
        }
    }
}
```

核心组件:

1. RenderPipeline
   - 渲染管线基类
   - 控制整体渲染流程
   - 管理渲染资源

2. RenderPipelineAsset
   - 配置资源
   - 创建管线实例
   - 序列化设置

3. ScriptableRenderer
   - 实现具体渲染
   - 管理渲染过程
   - 执行渲染命令

### 渲染上下文

```csharp
// 渲染上下文使用示例
public class CustomRenderer : ScriptableRenderer
{
    public override void Render(
        ScriptableRenderContext context,
        Camera camera)
    {
        // 1. 设置相机属性
        context.SetupCameraProperties(camera);

// 2. 创建命令缓冲区
        CommandBuffer cmd = CommandBufferPool.Get();

// 3. 清除渲染目标
        cmd.ClearRenderTarget(true, true, Color.black);
        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();

// 4. 剔除
        var cullingParameters = new ScriptableCullingParameters();
        if (camera.TryGetCullingParameters(out cullingParameters))
        {
            var cullingResults = context.Cull(ref cullingParameters);
            
            // 5. 绘制可见对象
            var sortingSettings = new SortingSettings(camera);
            var drawingSettings = new DrawingSettings(
                new ShaderTagId("SRPDefaultUnlit"),
                sortingSettings);
            var filteringSettings = new FilteringSettings(
                RenderQueueRange.opaque);

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

// 6. 提交渲染命令
        context.Submit();

// 7. 释放命令缓冲区
        CommandBufferPool.Release(cmd);
    }
}
```

ScriptableRenderContext功能:

1. 命令管理
   - 创建命令缓冲区
   - 执行渲染命令
   - 提交渲染状态

2. 渲染状态
   - 设置相机参数
   - 管理渲染目标
   - 控制渲染顺序

3. 渲染优化
   - 批处理支持
   - 多线程渲染
   - GPU实例化

## 渲染流程

### 渲染准备

```csharp
// 渲染准备示例
public class RenderingSetup
{
    private void PrepareForRendering(
        ScriptableRenderContext context,
        Camera camera)
    {
        // 1. 更新每帧数据
        PerFrameBuffer perFrameData = new PerFrameBuffer
        {
            viewMatrix = camera.worldToCameraMatrix,
            projectionMatrix = camera.projectionMatrix,
            time = Time.time
        };

// 2. 设置全局着色器变量
        CommandBuffer cmd = CommandBufferPool.Get();
        cmd.SetGlobalBuffer("_PerFrameData", perFrameData);

// 3. 配置渲染设置
        context.SetupCameraProperties(camera);
        cmd.ClearRenderTarget(true, true, camera.backgroundColor);

context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
}
```

准备阶段工作:

1. 相机设置
   - 视图矩阵
   - 投影矩阵
   - 视口配置

2. 缓冲区管理
   - 创建RT
   - 设置目标
   - 清除状态

3. 全局数据
   - 光照信息
   - 阴影数据
   - 时间变量

### 渲染过程

```csharp
// 渲染过程示例
public class RenderingProcess : ScriptableRenderer
{
    // 渲染通道定义
    private ShaderTagId[] shaderTags = new ShaderTagId[]
    {
        new ShaderTagId("SRPDefaultUnlit"),
        new ShaderTagId("CustomLit")
    };

protected void RenderObjects(
        ScriptableRenderContext context,
        CullingResults cullingResults,
        Camera camera)
    {
        // 1. 设置排序
        var sortingSettings = new SortingSettings(camera)
        {
            criteria = SortingCriteria.CommonOpaque
        };

// 2. 配置绘制设置
        var drawingSettings = new DrawingSettings(
            shaderTags[0], sortingSettings);
        for (int i = 1; i < shaderTags.Length; i++)
        {
            drawingSettings.SetShaderPassName(i, shaderTags[i]);
        }

// 3. 过滤设置
        var filteringSettings = new FilteringSettings(
            RenderQueueRange.opaque);

// 4. 绘制不透明物体
        context.DrawRenderers(
            cullingResults,
            ref drawingSettings,
            ref filteringSettings);

// 5. 绘制天空盒
        context.DrawSkybox(camera);

// 6. 设置透明物体排序
        sortingSettings.criteria = SortingCriteria.CommonTransparent;
        drawingSettings.sortingSettings = sortingSettings;
        filteringSettings.renderQueueRange = 
            RenderQueueRange.transparent;

// 7. 绘制透明物体
        context.DrawRenderers(
            cullingResults,
            ref drawingSettings,
            ref filteringSettings);
    }
}
```

渲染流程控制:

1. 渲染顺序
   - 不透明物体
   - 天空盒
   - 透明物体

2. 渲染设置
   - Shader Pass
   - 排序规则
   - 过滤条件

3. 批次优化
   - 动态批处理
   - 静态批处理
   - GPU Instancing

### 后处理

```csharp
// 后处理示例
public class PostProcessing
{
    private void ApplyPostProcess(
        ScriptableRenderContext context,
        Camera camera)
    {
        CommandBuffer cmd = CommandBufferPool.Get();

// 1. 创建后处理RT
        RenderTextureDescriptor descriptor = 
            new RenderTextureDescriptor(
                camera.pixelWidth,
                camera.pixelHeight,
                RenderTextureFormat.Default,
                0);

// 2. 后处理效果
        cmd.GetTemporaryRT(tempRT.id, descriptor);
        cmd.Blit(sourceRT.id, tempRT.id, postMaterial);
        cmd.Blit(tempRT.id, BuiltinRenderTextureType.CameraTarget);

// 3. 释放资源
        cmd.ReleaseTemporaryRT(tempRT.id);

context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }
}
```

后处理功能:

1. 效果支持
   - 色彩校正
   - 景深模糊
   - 屏幕特效

2. 性能优化
   - RT复用
   - 分辨率控制
   - 计算着色器

## 自定义管线

### 创建流程

```csharp
// 自定义渲染管线资产
[CreateAssetMenu(
    menuName = "Rendering/Custom Pipeline")]
public class CustomRenderPipelineAsset : RenderPipelineAsset
{
    [SerializeField]
    private bool enablePostProcessing = true;

[SerializeField]
    private bool enableShadows = true;

protected override RenderPipeline CreatePipeline()
    {
        return new CustomRenderPipeline(this);
    }
}

// 自定义渲染管线
public class CustomRenderPipeline : RenderPipeline
{
    private CustomRenderer renderer;

public CustomRenderPipeline(CustomRenderPipelineAsset asset)
    {
        // 1. 全局设置
        GraphicsSettings.lightsUseLinearIntensity = true;
        GraphicsSettings.useScriptableRenderPipelineBatching = true;

// 2. 创建渲染器
        renderer = new CustomRenderer(asset);
    }

protected override void Render(
        ScriptableRenderContext context,
        Camera[] cameras)
    {
        // 3. 渲染每个相机
        foreach (Camera camera in cameras)
        {
            renderer.Render(context, camera);
        }
    }
}
```

开发步骤:

1. 创建资产
   - 继承RenderPipelineAsset
   - 配置渲染选项
   - 创建管线实例

2. 实现管线
   - 继承RenderPipeline
   - 初始化设置
   - 控制渲染流程

3. 自定义渲染器
   - 继承ScriptableRenderer
   - 实现渲染逻辑
   - 管理渲染通道

### 优化技巧

```csharp
// 渲染优化示例
public class RenderingOptimization
{
    private void OptimizeRendering(
        ScriptableRenderContext context,
        CullingResults cullingResults)
    {
        // 1. 合批设置
        var drawingSettings = new DrawingSettings()
        {
            enableDynamicBatching = true,
            enableInstancing = true
        };

// 2. 自定义批处理
        var batchRendererGroup = new BatchRendererGroup();
        batchRendererGroup.AddBatch(
            mesh, subMeshIndex, material,
            layer, castShadows, receiveShadows,
            matrices, count);

// 3. 多线程渲染
        JobHandle handle = new RenderJob
        {
            parameters = renderParams
        }.Schedule(renderCount, 64);
        handle.Complete();
    }
}
```

优化方向:

1. 渲染批次
   - 自动批处理
   - 手动合批
   - 实例化渲染

2. 多线程
   - 并行剔除
   - 异步计算
   - Job System

3. 内存管理
   - 资源复用
   - 缓存优化
   - 内存池