[游戏开发]Unity 合并Mesh 将多个小的物体合并成一个大物体，同批次渲染

可直接调用的MergeUtils类
MergeUtils.MergeMesh会自动判断顶点是否超出合并最大顶点 然后分批
MergeUtils.MergeMesh3是直接合并

using System.Collections.Generic;

using UnityEditor;

using UnityEngine;
using UnityEngine.Rendering;


namespace OrcFramework.Game
{
    public class MergeUtils
    {

        /// <summary>
        /// 合并网格
        /// </summary>
        private static void MergeMesh2(GameObject parent, bool mergeSubMeshes = false)
        {
            MeshRenderer[] meshRenderers = parent.GetComponentsInChildren<MeshRenderer>();
            Material[] materials = new Material[meshRenderers.Length];
            for (int i = 0; i < meshRenderers.Length; i++)
            {
                materials[i] = meshRenderers[i].sharedMaterial;
            }

            MeshFilter[] meshFilters = parent.GetComponentsInChildren<MeshFilter>();   //获取 所有子物体的网格


            CombineInstance[] combineInstances = new CombineInstance[meshFilters.Length]; //新建一个合并组，长度与 meshfilters一致
            for (int i = 0; i < meshFilters.Length; i++)                                  //遍历
            {
                combineInstances[i].mesh = meshFilters[i].sharedMesh;                   //将共享mesh，赋值
                combineInstances[i].transform = meshFilters[i].transform.localToWorldMatrix; //本地坐标转矩阵，赋值
                GameObject.DestroyImmediate(meshFilters[i].gameObject);
            }
            Mesh newMesh = new Mesh();                                  //声明一个新网格对象
            newMesh.CombineMeshes(combineInstances, mergeSubMeshes, true);                    //将combineInstances数组传入函数
            parent.AddComponent<MeshFilter>().sharedMesh = newMesh; //给当前空物体，添加网格组件；将合并后的网格，给到自身网格

            parent.AddComponent<MeshRenderer>().sharedMaterials = materials;
        }



        public static GameObject[] MergeMesh(GameObject parent, bool mergeAll = true, bool deleteChildren = false, bool mergeSubMeshes = false)
        {
            List<GameObject> list = new List<GameObject>();
            int verts = 0;
            //存放要合并的父物体  
            Dictionary<int, GameObject> NewParent = new Dictionary<int, GameObject>();
            //获取所有网格过滤器;
            MeshFilter[] meshFilters = parent.GetComponentsInChildren<MeshFilter>();
            for (int i = 0; i < meshFilters.Length; i++)
            {
                verts += meshFilters[i].mesh.vertexCount;

                if (NewParent.ContainsKey((verts / 65536) + 1))
                {
                    meshFilters[i].transform.parent = NewParent[(verts / 65536) + 1].transform;
                }
                else
                {
                    GameObject wx = new GameObject("Combine");
                    wx.transform.parent = parent.transform;
                    NewParent.Add((verts / 65536) + 1, wx);
                    meshFilters[i].transform.parent = NewParent[(verts / 65536) + 1].transform;
                }


            }
            foreach (var item in NewParent)
            {
                list.Add(MergeUtils.MergeMesh3(item.Value, true, true));
            }

            if (deleteChildren)
            {

                //合并完成后删除子项
                for (int i = parent.transform.childCount - 1; i >= 0; i--)
                {
                    if (parent.transform.GetChild(i).name != "Combine")
                    {
                        GameObject.Destroy(parent.transform.GetChild(i).gameObject);
                    }
                }

            }

            return list.ToArray();
        }

        public static GameObject MergeMesh3(GameObject parent, bool mergeAll = true, bool deleteChildren = false, bool mergeSubMeshes = false)
        {
            //获取所有网格过滤器;
            MeshFilter[] meshFilters = parent.GetComponentsInChildren<MeshFilter>();
            //存放不同的材质球，相同的就存一个;
            Dictionary<string, Material> materials = new Dictionary<string, Material>();

            //存放要合并的网格对象;
            Dictionary<string, List<CombineInstance>> combines = new Dictionary<string, List<CombineInstance>>();
            for (int i = 0; i < meshFilters.Length; i++)
            {
                //构造一个网格合并结构体;
                CombineInstance combine = new CombineInstance();

                //给结构体的mesh赋值;
                combine.mesh = meshFilters[i].sharedMesh;
                combine.transform = meshFilters[i].transform.localToWorldMatrix;

                MeshRenderer renderer = meshFilters[i].GetComponent<MeshRenderer>();
                if (renderer == null)
                {
                    continue;
                }
                Material mat = renderer.sharedMaterial;

                if (!materials.ContainsKey(mat.name))
                {
                    materials.Add(mat.name, mat);
                }
                if (combines.ContainsKey(mat.name))
                {
                    combines[mat.name].Add(combine);
                }
                else
                {
                    List<CombineInstance> coms = new List<CombineInstance>();
                    coms.Add(combine);
                    combines[mat.name] = coms;
                }

                //Destroy(meshFilters[i].gameObject);
            }
            GameObject combineObj = new GameObject("Combine");
            combineObj.transform.parent = parent.transform;
            foreach (KeyValuePair<string, Material> mater in materials)
            {
                GameObject obj = new GameObject(mater.Key);
                obj.transform.parent = combineObj.transform;
                MeshFilter combineMeshFilter = obj.AddComponent<MeshFilter>();
                combineMeshFilter.mesh = new Mesh();

                //将引用相同材质球的网格合并;
                combineMeshFilter.sharedMesh.CombineMeshes(combines[mater.Key].ToArray(), true, true);
                Debug.LogError("网格定点数" + combineMeshFilter.sharedMesh.vertices);
                MeshRenderer rend = obj.AddComponent<MeshRenderer>();

                //指定材质球;
                rend.sharedMaterial = mater.Value;

                rend.shadowCastingMode = ShadowCastingMode.Off;
                rend.receiveShadows = true;
            }

            if (mergeAll)
            {
                MergeMesh2(combineObj);
                //Combine(combineObj)
            }


            if (deleteChildren)
            {

                //合并完成后删除子项
                for (int i = parent.transform.childCount - 1; i >= 0; i--)
                {
                    if (parent.transform.GetChild(i).name != "Combine")
                    {
                        GameObject.Destroy(parent.transform.GetChild(i).gameObject);
                    }
                }

            }

            return combineObj;
        }
        public static GameObject MergeMesh4(GameObject parent, bool mergeAll = true, bool deleteChildren = false, bool mergeSubMeshes = false)
        {

            //获取所有网格过滤器;
            MeshFilter[] meshFilters = parent.GetComponentsInChildren<MeshFilter>();
            //存放不同的材质球，相同的就存一个;
            Dictionary<string, Material> materials = new Dictionary<string, Material>();

            //存放要合并的网格对象;
            Dictionary<string, List<CombineInstance>> combines = new Dictionary<string, List<CombineInstance>>();
            for (int i = 0; i < meshFilters.Length; i++)
            {
                //构造一个网格合并结构体;
                CombineInstance combine = new CombineInstance();

                //给结构体的mesh赋值;
                combine.mesh = meshFilters[i].sharedMesh;
                combine.transform = meshFilters[i].transform.localToWorldMatrix;

                MeshRenderer renderer = meshFilters[i].GetComponent<MeshRenderer>();
                if (renderer == null)
                {
                    continue;
                }
                Material mat = renderer.sharedMaterial;

                if (!materials.ContainsKey(mat.name))
                {
                    materials.Add(mat.name, mat);
                }
                if (combines.ContainsKey(mat.name))
                {
                    combines[mat.name].Add(combine);
                }
                else
                {
                    List<CombineInstance> coms = new List<CombineInstance>();
                    coms.Add(combine);
                    combines[mat.name] = coms;
                }

                //Destroy(meshFilters[i].gameObject);
            }
            GameObject combineObj = new GameObject("Combine");
            combineObj.transform.parent = parent.transform;
            foreach (KeyValuePair<string, Material> mater in materials)
            {
                GameObject obj = new GameObject(mater.Key);
                obj.transform.parent = combineObj.transform;
                MeshFilter combineMeshFilter = obj.AddComponent<MeshFilter>();
                combineMeshFilter.mesh = new Mesh();

                //将引用相同材质球的网格合并;
                combineMeshFilter.sharedMesh.CombineMeshes(combines[mater.Key].ToArray(), true, true);
                Debug.LogError("网格定点数" + combineMeshFilter.sharedMesh.vertices);
                MeshRenderer rend = obj.AddComponent<MeshRenderer>();

                //指定材质球;
                rend.sharedMaterial = mater.Value;

                rend.shadowCastingMode = ShadowCastingMode.Off;
                rend.receiveShadows = true;
            }

            if (mergeAll)
            {
                MergeMesh2(combineObj);
                //Combine(combineObj)
            }


            if (deleteChildren)
            {

                //合并完成后删除子项
                for (int i = parent.transform.childCount - 1; i >= 0; i--)
                {
                    if (parent.transform.GetChild(i).name != "Combine")
                    {
                        GameObject.Destroy(parent.transform.GetChild(i).gameObject);
                    }
                }

            }

            return combineObj;
        }

    }
}