_batchGroup = new BatchRendererGroup(OnCulling);

public void UpdateBatch()
{
    // 首先移除之前所有的渲染批次
    while (_batchGroup.GetNumBatches() > 0)
    {
        _batchGroup.RemoveBatch(0);
    }

    // 每种Mesh/Material的组合为1个渲染批次
    // 返回值字典的Key为组合的标识，Value则用于收集地块的坐标
    Dictionary<string, BatchIdCollection> meshes = CollectMeshes(out var meshCnt);

    // meshCnt是所有Mesh的总数量，用于计算裁剪框
    _bounds = new NativeArray<AABB>(meshCnt, Allocator.Persistent);
    var boundIdx = 0;
    var jobDep = new JobHandle();

    // ResourceModule是用于加载模型资源的模块，和本文无关
    var resModule = GetModule<ResourceModule>();

    foreach (var kvp in meshes)
    {
        var mesh = resModule.GetMesh(kvp.Key);
        var mat = resModule.GetMaterial(kvp.Key);
        // 依次给BatchRendererGroup添加渲染批次
        // 根据Unity的限制，每个Batch最多只能渲染1023个对象，超出会出现奇怪的问题（比如编辑器直接崩溃。。）
        // 所以对于数量太多的Mesh/Material组合，我们也需要将其分成多个Batch依次渲染
        for (var i = 0; i < kvp.Value.Batches; ++i)
        {
            // 当前批次需要渲染的物体数量
            var count = kvp.Value.GetCount(i);

            // 具体参数的意义详见官方文档
            var batchId = _batchGroup.AddBatch(
                mesh, 0, mat, 0,
                ShadowCastingMode.On, true,
                false, _mapBounds, count,
                null, null
            );
            // 其中上面的_mapBounds是整个地图的范围，当该范围不在摄像机的裁剪视锥内时，整个Batch将会被自动裁剪

            // 从刚刚添加的Batch中获取表示世界变换矩阵以及叠加颜色属性的数组
            var transforms = _batchGroup.GetBatchMatrices(batchId);
            var colors = _batchGroup.GetBatchVectorArray(batchId, TintShaderPropId);
            // 这个是该批次的地块位置ID数组，我们可以通过ID来计算出对应的坐标
            var tileIds = kvp.Value.Get(i);
            // 该批次所渲染的网格的包围框，以本地坐标表示
            var localBounds = mesh.bounds.ToAABB();

            // 接下来要给每个要对象都设置坐标以及颜色，而这个操作对于每个对象之间是相互独立的
            // 所以我们安排一个Job来执行这些操作
            // 这个Job还兼容使用Burst编译器，优化后的运行时消耗几乎可忽略不计
            var job = new SetBatchDataJob
            {
                // 前两个是常量，为了兼容Burst，需要每次手动传入
                MapHeight = GameUtils.MapHeight,
                TintColorLut = _tintColorLut,
                // 输入项
                TileIds = tileIds,
                LocalBounds = localBounds,
                TintColors = _tintColors,
                BoundOffset = boundIdx,
                // 输出项
                Transforms = transforms,
                Colors = colors,
                // 最后一个是每个物体的裁剪框，以世界坐标表示，用于后面的裁剪函数
                AllBounds = _bounds
            };
            // 以并行执行的方式安排起来
            jobDep = job.Schedule(count, 64, jobDep);
            boundIdx += count;
        }
    }
    // 最后等待完成前面安排的所有Jobs
    jobDep.Complete();
}

public delegate JobHandle OnPerformCulling(
      BatchRendererGroup rendererGroup,
      BatchCullingContext cullingContext);

private JobHandle OnCulling(BatchRendererGroup group, BatchCullingContext context)
{
    var cnt = context.batchVisibility.Length;
    var job = new CullingJob
    {
        // FrustumPlanes来自于HybridRenderer包，需要额外导入进项目
        CullingPlanes = FrustumPlanes.BuildSOAPlanePackets(context.cullingPlanes, Allocator.TempJob),
        Boundses = _bounds,
        Batches = context.batchVisibility,
        Indices = context.visibleIndices
    };
    // _cullingDep存储当前作业的依赖，为了在析构时保证所有的作业都已完成
    var handle = job.Schedule(cnt, 4, _cullingDep);
    _cullingDep = JobHandle.CombineDependencies(handle, _cullingDep);
    return handle;
}

// 一定要启用Burst编译，性能可以提升10倍
[BurstCompile]
private struct CullingJob : IJobParallelFor
{
    // 下面的字段有一大堆花里胡哨的属性，一一解释下

    // 标记为只读，此时Unity的Job调度器就允许多个线程同时访问这个容器
    [ReadOnly]
    // Job完成时自动释放内存，这个容器是我们在创建Job时临时分配的
    // 而Job并不会立即完成，我们并不知道什么时候完成
    // 加上这个标签之后，Job完成时就会自动释放这个容器了
    [DeallocateOnJobCompletion]
    public NativeArray<FrustumPlanes.PlanePacket4> CullingPlanes;

    [ReadOnly]
    public NativeArray<AABB> Boundses;

    public NativeArray<BatchVisibility> Batches;

    // Unity默认不允许向Native容器并行写入（除非写入的索引等于Excute中的参数，比如上边的Batches）
    // 于是我们需要告诉Unity，虽然这个容器是需要写入的，但是我们保证不会从不同的线程向相同索引的元素中写入
    // 加上这个标签可以解除并行写入限制
    [NativeDisableParallelForRestriction]
    public NativeArray<int> Indices;

    public void Execute(int batchIdx)
    {
        // 逻辑十分简单，依次判断每个对象的范围是否在视锥体内
        var bv = Batches[batchIdx];
        var count = 0;
        for (var i = 0; i < bv.instancesCount; ++i)
        {
            var result = FrustumPlanes.Intersect2(CullingPlanes, Boundses[bv.offset + i]);
            if (result != FrustumPlanes.IntersectResult.Out)
            {
                Indices[bv.offset + count] = i;
                count++;
            }
        }
        bv.visibleCount = count;
        Batches[batchIdx] = bv;
    }
}