Dynamically combine verticies that share the same space

Numberkruncher I modified your code to use uniform spatial partitioning. Now it should be like 100 times faster on large meshes. Hope this can help someone.

   public static void AutoWeld (Mesh mesh, float threshold, float bucketStep) {
     Vector3[] oldVertices = mesh.vertices;
     Vector3[] newVertices = new Vector3[oldVertices.Length];
     int[] old2new = new int[oldVertices.Length];
     int newSize = 0;
 
     // Find AABB
     Vector3 min = new Vector3 (float.MaxValue, float.MaxValue, float.MaxValue);
     Vector3 max = new Vector3 (float.MinValue, float.MinValue, float.MinValue);
     for (int i = 0; i < oldVertices.Length; i++) {
       if (oldVertices[i].x < min.x) min.x = oldVertices[i].x;
       if (oldVertices[i].y < min.y) min.y = oldVertices[i].y;
       if (oldVertices[i].z < min.z) min.z = oldVertices[i].z;
       if (oldVertices[i].x > max.x) max.x = oldVertices[i].x;
       if (oldVertices[i].y > max.y) max.y = oldVertices[i].y;
       if (oldVertices[i].z > max.z) max.z = oldVertices[i].z;
     }
 
     // Make cubic buckets, each with dimensions "bucketStep"
     int bucketSizeX = Mathf.FloorToInt ((max.x - min.x) / bucketStep) + 1;
     int bucketSizeY = Mathf.FloorToInt ((max.y - min.y) / bucketStep) + 1;
     int bucketSizeZ = Mathf.FloorToInt ((max.z - min.z) / bucketStep) + 1;
     List<int>[,,] buckets = new List<int>[bucketSizeX, bucketSizeY, bucketSizeZ];
 
     // Make new vertices
     for (int i = 0; i < oldVertices.Length; i++) {
       // Determine which bucket it belongs to
       int x = Mathf.FloorToInt ((oldVertices[i].x - min.x) / bucketStep);
       int y = Mathf.FloorToInt ((oldVertices[i].y - min.y) / bucketStep);
       int z = Mathf.FloorToInt ((oldVertices[i].z - min.z) / bucketStep);
 
       // Check to see if it's already been added
       if (buckets[x, y, z] == null)
         buckets[x, y, z] = new List<int> (); // Make buckets lazily
 
       for (int j = 0; j < buckets[x, y, z].Count; j++) {
         Vector3 to = newVertices[buckets[x, y, z][j]] - oldVertices[i];
         if (Vector3.SqrMagnitude (to) < threshold) {
           old2new[i] = buckets[x, y, z][j];
           goto skip; // Skip to next old vertex if this one is already there
         }
       }
 
       // Add new vertex
       newVertices[newSize] = oldVertices[i];
       buckets[x, y, z].Add (newSize);
       old2new[i] = newSize;
       newSize++;
 
     skip:;
     }
 
     // Make new triangles
     int[] oldTris = mesh.triangles;
     int[] newTris = new int[oldTris.Length];
     for (int i = 0; i < oldTris.Length; i++) {
       newTris[i] = old2new[oldTris[i]];
     }
     
     Vector3[] finalVertices = new Vector3[newSize];
     for (int i = 0; i < newSize; i++)
       finalVertices[i] = newVertices[i];
 
     mesh.Clear();
     mesh.vertices = finalVertices;
     mesh.triangles = newTris;
     mesh.RecalculateNormals ();
     mesh.Optimize ();
   }

I think the answer is that this is not feasible. I have worked out how to write this logic and have points 1/3/4 working great. Here is the code that I wrote for step 2.

Whilst this does in fact weld the verticies together, it screws up the UV coordinates because it seems that there can only be one UV coordinate pair for each vertex. This has had the effect of (properly mapped->mirrored->stretched->mirrored->properly mapped->...)

If anybody knows how to solve this problem then that would be fantastic. Still, here is the welding code that I wrote should it be of any use to anybody:

     private void AutoWeld(Mesh mesh, float threshold) {
         Vector3[] verts = mesh.vertices;
         
         // Build new vertex buffer and remove "duplicate" verticies
         // that are within the given threshold.
         List<Vector3> newVerts = new List<Vector3>();
         List<Vector2> newUVs = new List<Vector2>();
         
         int k = 0;
         
         foreach (Vector3 vert in verts) {
             // Has vertex already been added to newVerts list?
             foreach (Vector3 newVert in newVerts)
                 if (Vector3.Distance(newVert, vert) <= threshold)
                     goto skipToNext;
             
             // Accept new vertex!
             newVerts.Add(vert);
             newUVs.Add(mesh.uv[k]);
             
         skipToNext:;
             ++k;
         }
         
         // Rebuild triangles using new verticies
         int[] tris = mesh.triangles;
         for (int i = 0; i < tris.Length; ++i) {
             // Find new vertex point from buffer
             for (int j = 0; j < newVerts.Count; ++j) {
                 if (Vector3.Distance(newVerts[j], verts[ tris[i] ]) <= threshold) {
                     tris[i] = j;
                     break;
                 }
             }
         }
         
         // Update mesh!
         mesh.Clear();
         mesh.vertices = newVerts.ToArray();
         mesh.triangles = tris;
         mesh.uv = newUVs.ToArray();
         mesh.RecalculateBounds();
     }

is Uv destroy for my try but vertex working

I found this tool, the Oasis Mesh Editor, that can Split Vertices and Merge Vertices back together, https://assetstore.unity.com/packages/slug/166155

The Merge Verts tool also has a Max Tolerance setting so that only verts that are closer than this distance will be merged.

Hope this helps anyone looking =)