深入理解 BatchRendererGroup：从渲染批处理的前世今生说起#

1
CPU                          GPU
2
  |                            |
3
  |---- 设置顶点缓冲区 -------->|
4
  |---- 设置材质参数 ---------->|
5
  |---- 设置变换矩阵 ---------->|
6
  |---- 发送绘制命令 --------->|  ← Draw Call
7
  |                            |---- 执行顶点着色器
8
  |                            |---- 执行片元着色器
9
  |                            |---- 输出到帧缓冲

1
原始状态：                          批处理后：
2
[Mesh A] [Mesh B] [Mesh C]    →    [Combined Mesh: A+B+C]
3
   ↓         ↓         ↓                  ↓
4
Draw()   Draw()     Draw()           Draw() (一次调用)

1
// 在 Unity 中，只需在 Inspector 中勾选 Static
2
// 或通过代码设置
3
gameObject.isStatic = true;

1
静态批处理前的顶点缓冲区：
2
Mesh A: [v0, v1, v2, v3]
3
Mesh B: [v4, v5, v6]
4
Mesh C: [v7, v8, v9, v10, v11]
5

6
静态批处理后的顶点缓冲区：
7
Combined: [v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11]

1
帧 N：
2
检测可合并物体 → 合并顶点 → 单次绘制
3

4
帧 N+1：
5
物体移动 → 重新检测 → 重新合并 → 单次绘制

1
void DynamicBatching()
2
{
3
    List<MeshRenderer> batchableRenderers = FindBatchableRenderers();
4

5
    // 检查是否满足批处理条件
6
    foreach (var renderer in batchableRenderers)
7
    {
8
        if (renderer.sharedMaterial != currentMaterial) continue;
9
        if (renderer.mesh.vertexCount > 900) continue;
10
        // ... 更多检查
11
    }
12

13
    // 动态合并顶点数据
14
    CombineInstance[] combine = new CombineInstance[batchableRenderers.Count];
15
    for (int i = 0; i < batchableRenderers.Count; i++)
16
    {
17
        combine[i].mesh = batchableRenderers[i].mesh;
18
        combine[i].transform = batchableRenderers[i].transform.localToWorldMatrix;
19
    }
20

21
    Mesh combinedMesh = new Mesh();
22
    combinedMesh.CombineMeshes(combine);
23
    Graphics.DrawMesh(combinedMesh, ...);
24
}

1
// 顶点着色器
2
#version 330 core
3
layout (location = 0) in vec3 aPos;
4
layout (location = 2) in vec2 aOffset;  // 实例化属性
5

6
void main()
7
{
8
    gl_Position = vec4(aPos + aOffset, 0.0, 1.0);
9
}

1
// C++ 端设置实例化数组
2
unsigned int instanceVBO;
3
glGenBuffers(1, &instanceVBO);
4
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
5
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 100, &translations[0], GL_STATIC_DRAW);
6

7
// 关键：glVertexAttribDivisor
8
glEnableVertexAttribArray(2);
9
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0);
10
glVertexAttribDivisor(2, 1);  // 每个实例更新一次，而不是每个顶点
11

12
// 绘制 100 个实例
13
glDrawArraysInstanced(GL_TRIANGLES, 0, 6, 100);

1
普通顶点属性（divisor = 0）：
2
顶点 0 → 属性 A
3
顶点 1 → 属性 B
4
顶点 2 → 属性 C
5
...
6

7
实例化属性（divisor = 1）：
8
实例 0 的所有顶点 → 属性 A
9
实例 1 的所有顶点 → 属性 B
10
实例 2 的所有顶点 → 属性 C
11
...

1
MaterialPropertyBlock props = new MaterialPropertyBlock();
2
MeshRenderer renderer;
3

4
foreach (var obj in objects)
5
{
6
    props.SetColor("_Color", obj.color);
7
    props.SetMatrix("_ObjectToWorld", obj.transform.localToWorldMatrix);
8
    renderer.SetPropertyBlock(props);
9
}
10

11
// 使用 Graphics.DrawMeshInstanced
12
Graphics.DrawMeshInstanced(mesh, 0, material, matrices, count);

1
传统渲染：
2
Draw(A) → 切换材质 → Draw(B) → 切换材质 → Draw(C)
3
         ↑ 开销大          ↑ 开销大          ↑ 开销大
4

5
SRP Batcher：
6
Bind(材质A) → Draw(A) → Draw(B) → Draw(C) → Unbind
7
             ↑ 仅一次状态切换

1
CPU 内存：                    GPU 内存：
2
[Material A Props]    →     [Persistent Buffer]
3
[Material B Props]    →     [Persistent Buffer]
4
[Material C Props]    →     [Persistent Buffer]
5

6
渲染时：
7
GPU 直接从持久化缓冲区读取数据
8
不需要 CPU 每帧重新上传

1
// SRP Batcher 兼容的 Shader 必须使用 CBUFFER
2
CBUFFER_START(UnityPerDraw)
3
    float4x4 unity_ObjectToWorld;
4
    float4x4 unity_WorldToObject;
5
CBUFFER_END
6

7
CBUFFER_START(UnityPerMaterial)
8
    float4 _BaseColor;
9
    float _Metallic;
10
    float _Smoothness;
11
CBUFFER_END

1
// 每帧的开销
2
foreach (var obj in gameObjects)  // 10,000+ 迭代
3
{
4
    obj.transform.position += velocity * Time.deltaTime;  // Transform 更新开销
5
    renderer.material.SetColor("_Color", obj.color);       // 材质属性设置开销
6
}
7

8
// Unity 内部还要处理：
9
// - Transform 层级更新
10
// - 消息广播
11
// - 序列化
12
// - 内存分配/GC

1
主线程：
2
PrepareRenderCommands() → 10ms+
3
    ↓
4
渲染线程：
5
ExecuteRenderCommands() → 2ms

1
GraphicsBuffer 布局：
2
┌─────────────────────────────────────────────────────────────┐
3
│ 偏移量 0-63: 64 字节的零（约定俗成，方便加载默认值）           │
4
├─────────────────────────────────────────────────────────────┤
5
│ 偏移量 64-95: 32 字节未初始化（对齐用）                       │
6
├─────────────────────────────────────────────────────────────┤
7
│ 偏移量 96+: unity_ObjectToWorld 数组                         │
8
│   每个实例 48 字节 (float3x4)                                │
9
│   实例 0: [c0.x, c0.y, c0.z, c1.x, c1.y, c1.z, c2.x, ...]   │
10
│   实例 1: [c0.x, c0.y, c0.z, c1.x, c1.y, c1.z, c2.x, ...]   │
11
│   ...                                                        │
12
├─────────────────────────────────────────────────────────────┤
13
│ unity_WorldToObject 数组（逆矩阵）                           │
14
│   每个实例 48 字节 (float3x4)                                │
15
└─────────────────────────────────────────────────────────────┘

1
// Matrix4x4 按行存储
2
Matrix4x4 matrix = new Matrix4x4(
3
    m00, m01, m02, m03,  // 第一行
4
    m10, m11, m12, m13,  // 第二行
5
    m20, m21, m22, m23,  // 第三行
6
    m30, m31, m32, m33   // 第四行
7
);
8

9
// float3x4 按列存储（BRG 要求的格式）
10
float3x4 packedMatrix = new float3x4(
11
    m00, m10, m20, m01,  // 第一列
12
    m11, m21, m02, m12,  // 第二列
13
    m22, m03, m13, m23   // 第三列
14
);
15
// 注意：最后一行 (m30, m31, m32, m33) 通常是 (0, 0, 0, 1)

1
public static float3x4 ToFloat3x4(Matrix4x4 m)
2
{
3
    // 从按行存储转换为按列存储
4
    return new float3x4(
5
        m.m00, m.m10, m.m20, m.m01,
6
        m.m11, m.m21, m.m02, m.m12,
7
        m.m22, m.m03, m.m13, m.m23
8
    );
9
}

1
using UnityEngine;
2
using UnityEngine.Rendering;
3
using Unity.Mathematics;
4

5
public class SimpleBRGExample : MonoBehaviour
6
{
7
    [SerializeField] private Mesh _mesh;
8
    [SerializeField] private Material _material;
9
    [SerializeField] private uint _instanceCount = 1000;
10

11
    private BatchRendererGroup _brg;
12
    private GraphicsBuffer _instanceData;
13
    private BatchID _batchID;
14
    private BatchMaterialID _materialID;
15
    private BatchMeshID _meshID;
16

17
    private const int SizeOfPackedMatrix = 48; // sizeof(float3x4)
18
    private const int ExtraBytes = 96; // 64 zeroes + 32 uninitialized
19

20
    void Start()
21
    {
22
        InitializeBRG();
23
    }
24

25
    void InitializeBRG()
26
    {
27
        // 1. 创建 BatchRendererGroup
28
        _brg = new BatchRendererGroup(OnPerformCulling, IntPtr.Zero);
29

30
        // 2. 设置全局包围盒
31
        var bounds = new Bounds(Vector3.zero, new Vector3(10000, 10000, 10000));
32
        _brg.SetGlobalBounds(bounds);
33

34
        // 3. 注册网格和材质
35
        _meshID = _brg.RegisterMesh(_mesh);
36
        _materialID = _brg.RegisterMaterial(_material);
37

38
        // 4. 创建 GPU 缓冲区
39
        int bufferCount = BufferCountForInstances(SizeOfPackedMatrix, (int)_instanceCount, ExtraBytes);
40
        _instanceData = new GraphicsBuffer(GraphicsBuffer.Target.Raw, bufferCount, 4);
41

42
        // 5. 准备实例数据
43
        float3x4[] objectToWorld = new float3x4[_instanceCount];
44
        float3x4[] worldToObject = new float3x4[_instanceCount];
45

46
        for (int i = 0; i < _instanceCount; i++)
47
        {
48
            var pos = Random.insideUnitSphere * 50;
49
            var matrix = Matrix4x4.TRS(pos, Quaternion.identity, Vector3.one);
50
            objectToWorld[i] = ToFloat3x4(matrix);
51
            worldToObject[i] = ToFloat3x4(matrix.inverse);
52
        }
53

54
        // 6. 上传数据到 GPU
55
        uint byteAddressObjectToWorld = SizeOfPackedMatrix * 2;
56
        uint byteAddressWorldToObject = byteAddressObjectToWorld + SizeOfPackedMatrix * _instanceCount;
57

58
        _instanceData.SetData(new float4[16], 0, 0, 16); // 零填充
59
        _instanceData.SetData(objectToWorld, 0, (int)(byteAddressObjectToWorld / SizeOfPackedMatrix), objectToWorld.Length);
60
        _instanceData.SetData(worldToObject, 0, (int)(byteAddressWorldToObject / SizeOfPackedMatrix), worldToObject.Length);
61

62
        // 7. 设置元数据
63
        var metadata = new NativeArray<MetadataValue>(2, Allocator.Temp);
64
        metadata[0] = new MetadataValue
65
        {
66
            NameID = Shader.PropertyToID("unity_ObjectToWorld"),
67
            Value = 0x80000000 | byteAddressObjectToWorld  // 最高位表示数组
68
        };
69
        metadata[1] = new MetadataValue
70
        {
71
            NameID = Shader.PropertyToID("unity_WorldToObject"),
72
            Value = 0x80000000 | byteAddressWorldToObject
73
        };
74

75
        // 8. 添加批次
76
        _batchID = _brg.AddBatch(metadata, _instanceData.bufferHandle);
77

78
        metadata.Dispose();
79
    }
80

81
    // 剔除回调
82
    unsafe JobHandle OnPerformCulling(BatchRendererGroup rendererGroup, BatchCullingContext cullingContext, BatchCullingOutput cullingOutput, IntPtr userContext)
83
    {
84
        var drawCommands = new NativeArray<BatchDrawCommand>(1, Allocator.TempJob);
85
        var drawRanges = new NativeArray<BatchDrawRange>(1, Allocator.TempJob);
86
        var filteringSettings = new NativeArray<BatchFilteringSettings>(1, Allocator.TempJob);
87

88
        drawCommands[0] = new BatchDrawCommand
89
        {
90
            batchID = _batchID,
91
            materialID = _materialID,
92
            meshID = _meshID,
93
            subMeshIndex = 0,
94
            visibleCount = (uint)_instanceCount,
95
            instanceOffset = 0
96
        };
97

98
        // ... 设置 drawRanges 和 filteringSettings
99

100
        cullingOutput.drawCommands[0] = drawCommands;
101
        cullingOutput.drawRanges[0] = drawRanges;
102
        cullingOutput.filteringSettings[0] = filteringSettings;
103

104
        return default;
105
    }
106

107
    void OnDestroy()
108
    {
109
        _brg.Dispose();
110
        _instanceData?.Dispose();
111
    }
112
}

1
PostLateUpdate.UpdateAllRenderers: 8-10ms  ← Transform 更新开销
2
Rendering: 4-5ms                          ← 每个对象独立绘制

1
Update (并行 Job): 0.3ms                  ← 数据导向更新
2
Rendering: 2ms                            ← 单次 Draw Call

1
[BurstCompile]
2
public unsafe struct CopyMatricesJob : IJobParallelFor
3
{
4
    [ReadOnly] public float4x4* Source;
5
    [WriteOnly] public NativeArray<Vector4> DataBuffer;
6
    public int Size;
7

8
    public void Execute(int index)
9
    {
10
        int offset = 4 + index * 3;
11
        DataBuffer[offset + 0] = new Vector4(Source[index].c0.x, Source[index].c0.y, Source[index].c0.z, Source[index].c1.x);
12
        DataBuffer[offset + 1] = new Vector4(Source[index].c1.y, Source[index].c1.z, Source[index].c2.x, Source[index].c2.y);
13
        DataBuffer[offset + 2] = new Vector4(Source[index].c2.z, Source[index].c3.x, Source[index].c3.y, Source[index].c3.z);
14

15
        // 逆矩阵...
16
    }
17
}

1
// 错误：每帧分配
2
void Update()
3
{
4
    var matrices = new float3x4[count];  // GC 压力
5
    // ...
6
}
7

8
// 正确：预分配并复用
9
private NativeArray<float3x4> _matrices;
10

11
void Start()
12
{
13
    _matrices = new NativeArray<float3x4>(count, Allocator.Persistent);
14
}

1
unsafe JobHandle OnPerformCulling(...)
2
{
3
    // 使用 Job System 并行剔除
4
    var cullingJob = new FrustumCullingJob
5
    {
6
        CameraPlanes = cullingContext.cullingPlanes,
7
        InstancePositions = _positions,
8
        VisibleIndices = _visibleIndices,
9
        VisibleCount = _visibleCount
10
    }.Schedule(_instanceCount, 64);
11

12
    return cullingJob;
13
}

1
CPU                           GPU
2
  |                             |
3
  |--- glBufferData ----------->|  上传实例数据
4
  |--- glVertexAttribPointer -->|  设置属性指针
5
  |--- glVertexAttribDivisor -->|  设置实例化频率
6
  |--- glDraw*Instanced ------->|  绘制

1
C# 代码                        Unity 内部                GPU
2
  |                              |                         |
3
  |-- GraphicsBuffer.SetData --->|                         |
4
  |-- AddBatch(metadata) ------->|                         |
5
  |                              |-- 注册到 SRP ----------->|
6
  |                              |                         |
7
  |-- OnPerformCulling --------->|                         |
8
  |                              |-- 生成 Draw Commands --->|
9
  |                              |-- glDraw*Instanced ----->|

1
#version 330 core
2
layout (location = 3) in mat4 instanceMatrix;
3

4
void main()
5
{
6
    gl_Position = projection * view * instanceMatrix * vec4(aPos, 1.0);
7
}

1
// Unity 需要使用 DOTS_INSTANCING_ON
2
#ifdef UNITY_DOTS_INSTANCING_ENABLED
3
    UNITY_DOTS_INSTANCING_START(float4x4, unity_ObjectToWorld)
4
        UNITY_DOTS_INSTANCING_END(float4x4)
5
#endif
6

7
void main()
8
{
9
    // BRG 通过元数据自动填充这些值
10
    float4x4 objectToWorld = UNITY_DOTS_INSTANCED_PROP(float4x4, unity_ObjectToWorld);
11
    gl_Position = VP * objectToWorld * float4(positionOS, 1.0);
12
}

1
需要渲染大量相同物体？
2
├── 是
3
│   ├── 使用 DOTS？
4
│   │   └── 是 → BatchRendererGroup
5
│   │   └── 否 →
6
│   │       ├── 物体移动？
7
│   │       │   └── 是 → GPU Instancing / SRP Batcher
8
│   │       │   └── 否 → Static Batching
9
│   │       └── 自定义剔除需求？
10
│   │           └── 是 → BatchRendererGroup
11
│   └── 否 → SRP Batcher（如果使用 URP/HDRP）
12
└── 少量物体
13
    └── GameObjects + SRP Batcher