public static Mesh Combine(MeshFilter[] filters, bool weld)
        {
            if (filters.Length == 0)
            {
                Debug.LogError("Mesh list is empty.");
                return(null);
            }

            Transform root      = filters[0].transform;
            int       meshCount = filters.Length;

            MeshExtended[] extended = new MeshExtended[meshCount];
            for (int m = 0; m < meshCount; m++)
            {
                MeshFilter filter = filters[m];
                extended[m] = new MeshExtended();
                extended[m].Prepare(filter.sharedMesh, weld, root, filter.GetComponent <Transform>(), MeshExtended.SizeMethod.Bounds);
            }

            UVPackerSqr.Box[] boxes         = UVPackerSqr.Pack(extended);
            Mesh           combined         = new Mesh();
            List <Vector3> combinedVertices = new List <Vector3>();
            List <Vector2> combinedUVs      = new List <Vector2>();
            List <Vector3> combinedNormals  = new List <Vector3>();
            List <int>     combinedTris     = new List <int>();
            int            triOffset        = 0;

            for (int meshIndex = 0; meshIndex < meshCount; meshIndex++)
            {
                MeshExtended extmesh     = boxes[meshIndex].Extended;
                Vector3[]    vertices    = extmesh.Vertices;
                Vector2[]    uvs         = boxes[meshIndex].PackedUVs;
                Vector3[]    normals     = extmesh.Normals;
                int[]        triangles   = extmesh.Triangles;
                int          vertexCount = vertices.Length;
                int          triCount    = triangles.Length;

                for (int v = 0; v < vertexCount; v++)
                {
                    combinedVertices.Add(vertices[v]);
                    combinedUVs.Add(uvs[v]);
                    combinedNormals.Add(normals[v]);
                }

                for (int t = 0; t < triCount; t++)
                {
                    combinedTris.Add(triangles[t] + triOffset);
                }
                triOffset = combinedVertices.Count;
            }

            UVPacker.AdjustSpace(combinedUVs);

            combined.SetVertices(combinedVertices);
            combined.SetUVs(0, combinedUVs);
            combined.SetNormals(combinedNormals);
            combined.SetTriangles(combinedTris, 0);

            return(combined);
        }
Exemple #2
0
    public void Calculate(int index = 0)
    {
        Vertices.Clear();
        Triangles.Clear();
        UVs.Clear();

        var s = Size / 2f;

        Vector3[] p = new Vector3[] {
            new Vector3(-s, -s, -s) + Position,             // 0 0
            new Vector3(-s, s, -s) + Position,              // 1 1
            new Vector3(s, s, -s) + Position,               // 2 2
            new Vector3(s, -s, -s) + Position,              // 3 3

            new Vector3(-s, -s, s) + Position,              // 4 0
            new Vector3(-s, s, s) + Position,               // 5 1
            new Vector3(s, s, s) + Position,                // 6 2
            new Vector3(s, -s, s) + Position,               // 7 3
        };

        for (int i = 0; i < Faces.Length; i++)
        {
            if (Faces[i])
            {
                Triangles.AddRange(AddTriangles(index + Vertices.Count));
                UVs.AddRange(UVPacker.GetCubeUVs(i, CubeTypes[type]));

                switch (i)
                {
                case 0: Vertices.AddRange(new Vector3[] { p[0], p[1], p[2], p[3] }); break;

                case 1: Vertices.AddRange(new Vector3[] { p[3], p[2], p[6], p[7] }); break;

                case 2: Vertices.AddRange(new Vector3[] { p[7], p[6], p[5], p[4] }); break;

                case 3: Vertices.AddRange(new Vector3[] { p[4], p[5], p[1], p[0] }); break;

                case 4: Vertices.AddRange(new Vector3[] { p[1], p[5], p[6], p[2] }); break;

                case 5: Vertices.AddRange(new Vector3[] { p[4], p[0], p[3], p[7] }); break;

                default: break;
                }
            }
        }

        this.Calculated = true;
    }