【Unity】RenderMeshIndirectを使用して多量描画の負荷を抑えてみた

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

/// <summary>
/// GPUInstancing描画テストクラス
/// </summary>
public class TestGPUInstancing : MonoBehaviour
{
    // RenderMeshIndirect用
    private const           int CommandCount        = 1;
    private static readonly int PropertyID_Matrices = Shader.PropertyToID("_Matrices");

    [SerializeField]    private GameObject                                  objPrefab       = null;
    [SerializeField]    private int                                         drawNum         = 0;
    [SerializeField]    private Vector3                                     viewBasePos     = Vector3.zero;
    [SerializeField]    private Vector2Int                                  viewArea        = Vector2Int.zero;

                        private GameObject                                  drawBaseObj     = null;
                        private Mesh                                        mesh            = null;
                        private MeshRenderer                                meshRenderer    = null;
                        private Matrix4x4[]                                 matrices        = null;

                        // RenderMeshIndirect用
                        private RenderParams[]                              renderParams    = null;
                        private GraphicsBuffer                              indirectBuf     = null;
                        private GraphicsBuffer                              matricesBuf     = null;
                        private GraphicsBuffer.IndirectDrawIndexedArgs[]    commandDatas    = null;

    /// <summary>
    /// 起動
    /// </summary>
    void Awake()
    {
        // 描画元オブジェクト生成
        drawBaseObj = GameObject.Instantiate(objPrefab, Vector3.zero, Quaternion.identity, transform);
        drawBaseObj.SetActive(false);

        // 表示位置設定
        var randm = new System.Random();
        matrices = new Matrix4x4[drawNum];
        var colors = new Color[drawNum];
        for (int i = 0; i < drawNum; i++)
        {
            var addPosX = (float)(randm.Next() % viewArea.x);
            var addPosY = (float)(randm.Next() % 40) / 10f;
            var addPosZ = (float)(randm.Next() % viewArea.y);
            var addPos = new Vector3(addPosX, addPosY, addPosZ);
            var setPos = viewBasePos + addPos;

            matrices[i] = Matrix4x4.TRS(
                    setPos,
                    Quaternion.identity,
                    Vector3.one
                );
            matrices[i] *= meshRenderer.transform.localToWorldMatrix;
        }

        // 描画に必要な要素を取得
        mesh            = drawBaseObj.GetComponentInChildren<MeshFilter>().mesh;
        meshRenderer    = drawBaseObj.GetComponentInChildren<MeshRenderer>();

        // RenderMeshIndirect用に描画情報を設定
        matricesBuf = new GraphicsBuffer(GraphicsBuffer.Target.Structured, matrices.Length, 4 * 4 * sizeof(float));
        matricesBuf.SetData(matrices);

        commandDatas = new GraphicsBuffer.IndirectDrawIndexedArgs[CommandCount];
        commandDatas[0].indexCountPerInstance = mesh.GetIndexCount(0);
        commandDatas[0].baseVertexIndex = mesh.GetBaseVertex(0);
        commandDatas[0].startIndex = mesh.GetIndexStart(0);
        commandDatas[0].instanceCount = (uint)matrices.Length;

        indirectBuf = new GraphicsBuffer(GraphicsBuffer.Target.IndirectArguments, CommandCount, GraphicsBuffer.IndirectDrawIndexedArgs.size);
        indirectBuf.SetData(commandDatas);

        renderParams = new RenderParams[meshRenderer.sharedMaterials.Length];
        for (int i = 0; i < meshRenderer.sharedMaterials.Length; ++i)
        {
            renderParams[i] = new RenderParams(meshRenderer.sharedMaterials[i])
            {
                worldBounds = new Bounds(Vector3.zero, 10000 * Vector3.one),
                matProps = new MaterialPropertyBlock(),
                shadowCastingMode = ShadowCastingMode.On,
                receiveShadows = true,
                layer = drawBaseObj.layer,
                camera = null,
                lightProbeUsage = LightProbeUsage.BlendProbes,
                lightProbeProxyVolume = null
            };

            renderParams[i].matProps.SetBuffer(PropertyID_Matrices, matricesBuf);
        }
    }

    /// <summary>
    /// 更新
    /// </summary>
    private void Update()
    {
        if (mesh == null)           return;
        if (meshRenderer == null)   return;
        if (matrices == null)       return;
        if (matrices.Length <= 0)   return;

        for (int i = 0; i < meshRenderer.sharedMaterials.Length; ++i)
        {
            UnityEngine.Graphics.RenderMeshIndirect(
                renderParams[i],
                mesh,
                indirectBuf,
                CommandCount
            );
        }
    }

    /// <summary>
    /// 破棄
    /// </summary>
    private void OnDestroy()
    {
        matricesBuf?.Dispose();
        matricesBuf = null;

        colorsBuf?.Dispose();
        colorsBuf = null;
    }
}

    // CullingGroup用
    private CullingGroup                                cullingGroup    = null;
    private BoundingSphere[]                            bounds          = null;
    private Dictionary<int, Matrix4x4>                  cullingMatrices = new Dictionary<int, Matrix4x4>();     // 描画位置
    private Matrix4x4[]                                 drawMatrices    = null;
    private bool                                        calcDrawFlag    = false;

    /// <summary>
    /// 起動
    /// </summary>
    void Awake()
    {
        // 変わらない部分は省略…

        //------------------------------------------------------------
        // カリング設定
        //------------------------------------------------------------
        // カリングを行うカメラを設定
        cullingGroup = new CullingGroup();
        cullingGroup.targetCamera = Camera.main;
        cullingGroup.SetDistanceReferencePoint(Camera.main.transform);

        // 視界判定情報を設定
        bounds = new BoundingSphere[matrices.Length];
        for (int i = 0; i < matrices.Length; i++)
        {
            bounds[i].position = matrices[i].GetPosition();
            bounds[i].radius   = matrices[i].lossyScale.magnitude;
        }
        cullingGroup.SetBoundingSpheres(bounds);
        cullingGroup.SetBoundingSphereCount(bounds.Length);

        // 視認状態が変化した際のコールバックを登録
        cullingGroup.onStateChanged = OnChangeRange;
        //------------------------------------------------------------
    }

    /// <summary>
    /// カリング範囲外or内へ移動の検知
    /// </summary>
    /// <param name="ev">CullingGroupEvent情報</param>
    private void OnChangeRange( CullingGroupEvent ev )
    {
        if (ev.isVisible)
        {
            cullingMatrices[ev.index]   = matrices[ev.index];
        }
        else
        {
            cullingMatrices.Remove(ev.index);
        }
        calcDrawFlag = true;
    }

    /// <summary>
    /// 更新
    /// </summary>
    private void Update()
    {
        if (mesh == null)           return;
        if (meshRenderer == null)   return;

        // カリング結果を反映
        if (calcDrawFlag)
        {
            drawMatrices    = cullingMatrices.Values.ToArray();
            if ( drawMatrices.Length <= 0 ) return;

            // 表示位置設定
            matricesBuf.SetData(drawMatrices);
            for (int h = 0; h < meshRenderer.sharedMaterials.Length; ++h)
            {
                renderParams[h].matProps.SetBuffer(PropertyID_Matrices, matricesBuf);
            }

            // 描画数更新
            commandDatas[0].instanceCount = (uint)drawMatrices.Length;
            indirectBuf.SetData(commandDatas);
            
            calcDrawFlag    = false;
        }
        if (drawMatrices == null)       return;
        if (drawMatrices.Length <= 0)   return;

        for (int i = 0; i < meshRenderer.sharedMaterials.Length; ++i)
        {
            UnityEngine.Graphics.RenderMeshIndirect(
                renderParams[i],
                mesh,
                indirectBuf,
                CommandCount
            );
        }
    }

            drawMatrices    = cullingMatrices.Values.ToArray();
            if ( drawMatrices.Length <= 0 ) return;