一个网格合并(weld)小工具

namespace Hont
{
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;

    public static class MeshCombinerUtil
    {
        public static Mesh Combine(MeshFilter[] meshFilterArary, float weldDistance = 0.01f)
        {
            const int MESH_VERT_GAP = 10_0000;

            Dictionary<int, int> newTrianglesDict = new Dictionary<int, int>();
            List<int> newTrianglesList = new List<int>();
            List<Vector3> newVerticesList = new List<Vector3>();
            List<KeyValuePair<Vector3, int>> meshSlotList = new List<KeyValuePair<Vector3, int>>();

            int counter = 0;
            for (int i = 0; i < meshFilterArary.Length; i++)
            {
                MeshFilter meshFilter = meshFilterArary[i];
                Mesh mesh = meshFilter.sharedMesh;

                Vector3[] verticesArray = mesh.vertices;
                int[] trianglesArray = mesh.triangles;

                for (int j = 0; j < trianglesArray.Length; j++)
                {
                    int triangleIndex = trianglesArray[j];
                    int triangleIndexContainOffset = triangleIndex + i * MESH_VERT_GAP;
                    Vector3 vertex = verticesArray[triangleIndex];
                    vertex = meshFilter.transform.localToWorldMatrix.MultiplyPoint3x4(vertex);

                    if (!newTrianglesDict.ContainsKey(triangleIndexContainOffset))
                    {
                        KeyValuePair<Vector3, int> slotInfo = new KeyValuePair<Vector3, int>(Vector3.zero, -1);
                        for (int k = 0; k < meshSlotList.Count; k++)
                        {
                            KeyValuePair<Vector3, int> meshSlot = meshSlotList[k];

                            if (Vector3.Distance(meshSlot.Key, vertex) <= weldDistance)
                            {
                                slotInfo = meshSlot;
                                break;
                            }
                        } //检索网格交错列表

                        if (slotInfo.Value > -1) //如果网格交错列表里有
                        {
                            newTrianglesDict.Add(triangleIndexContainOffset, slotInfo.Value);
                        }
                        else //如果网格交错列表里没有
                        {
                            meshSlotList.Add(new KeyValuePair<Vector3, int>(vertex, counter));
                            newTrianglesDict.Add(triangleIndexContainOffset, counter);

                            ++counter;
                            newVerticesList.Add(vertex);
                        }
                    } //如果这个原始三角形索引字典里没有则初始化

                    newTrianglesList.Add(newTrianglesDict[triangleIndexContainOffset]);
                }
            }

            Mesh newMesh = new Mesh();
            newMesh.SetVertices(newVerticesList);
            newMesh.SetTriangles(newTrianglesList, 0);

            return newMesh;
        }
    }
}