Splitting.cs

Go to the documentation of this file.

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

public class Splitting {
    private static int vertexLimit = 65000;
    private int[] triangles;
    private Vector3[] vertices;
    private Vector3[] normals;
    private Color32[] colors;
    private int currentIndex;
    private List<Mesh> meshes;
    private int lastIndex;
    
    public List<Mesh> Split(MeshData mData) {
        triangles = mData.triangles;
        vertices = mData.vertices;
        normals = mData.normals;
        colors = mData.colors;
        meshes = new List<Mesh>();

        if(UI.UIData.isGLIC)
            vertexLimit = 59520;
        
        // Small meshes don't need to be split
        if(mData.vertices.Length < vertexLimit) {
            Debug.Log("Vertices size : "+vertices.Length);
            Debug.Log("   triangle size : "+ triangles.Length);
            Mesh mesh = new Mesh();
            mesh.vertices = vertices;
            mesh.triangles = triangles;
            mesh.normals = normals;
            mesh.colors32 = colors;
            meshes.Add(mesh);
            return meshes;
        }
        
        lastIndex = triangles.Length;
        
        while(currentIndex < lastIndex) {
            FillMesh();
        }
        
        return meshes;
    }
    
    
    
    
    private void FillMesh() {
        List<int> tris = new List<int>();
        List<Vector3> verts = new List<Vector3>();
        List<Vector3> norms = new List<Vector3>();
        List<Color32> cols = new List<Color32>();
        Dictionary<int, int> dict = new Dictionary<int, int>();
        int currentVertex = 0;
        
        // Should not matter, as it should never be used unless dict.TryGetValue() succeeds
        int index = -1;
        int vIndex;
        bool useColors = (colors != null);
        
        bool roomLeft = true;
        
        while( roomLeft && (currentIndex < lastIndex) ) {
            // The dictionary may contain the correct index for this vertex
            // in the context of the current mesh. That means the vertex already exists
            // in the local mesh.
            if(dict.TryGetValue(triangles[currentIndex], out index)) {
                tris.Add(index);
            } else {
                // If not, we add it. The index of the vertex in the original
                // mesh is the key, and the value is currentVertex
                dict.Add(triangles[currentIndex], currentVertex);
                
                // We add the vertex, color and normal pointed to by the global index
                vIndex = triangles[currentIndex];
                verts.Add(vertices[vIndex]);
                norms.Add(normals[vIndex]);
                if(useColors)
                    cols.Add(colors[vIndex]);
                
                // But we reference it with the local index.
                tris.Add(currentVertex);
                currentVertex++;
            }
            // We don't want to exceed the vertex limit, which is something like 65534, but
            // we must also take care not to exit the function in the middle of a triangle.
            if( (currentVertex > vertexLimit) && ( (currentIndex+1) % 3 == 0) )
            //if(currentVertex > 10000)
                roomLeft = false;
            
            // Next item in triangles
            currentIndex ++;
            
        }
        
        Mesh mesh = new Mesh();
        mesh.vertices = verts.ToArray();
        mesh.triangles = tris.ToArray();
        mesh.normals = norms.ToArray();
        mesh.colors32 = cols.ToArray();
        
        meshes.Add(mesh);
    }
}