Ejemplo n.º 1
0
        void FillSoupsList()
        {
            br.BaseStream.Seek(lumps[7].offset, SeekOrigin.Begin);

            for (int i = 0; i < lumps[7].length / 16; i++)
            {
                TriangleSoup t = new TriangleSoup();

                t.materialID = br.ReadUInt16();
                t.drawOrder  = br.ReadUInt16();

                t.vertexOffset = br.ReadUInt32();
                t.vertexLength = br.ReadUInt16();

                t.triangleLength = br.ReadUInt16();
                t.triangleOffset = br.ReadUInt32();

                triangleSoups.Add(t);
            }
        }
Ejemplo n.º 2
0
        void CreateMeshMagic()
        {
            FillSoupsList();
            FillVerticesList();
            FillTrianglesList();
            FillMaterialList();

            List <Vector3> vertices = new List <Vector3>();
            List <Vector2> uvs      = new List <Vector2>();

            List <int> triangleIndices = new List <int>();

            // 1 soup per material/mesh
            // Each mesh has a triangle_length and triangle_offset
            // Triangle_length is how many triangles the mesh uses
            // Triangle_offset is the offset into the triangle array

            // Each soup also defines a vertex_offset
            // First you look up the current triangle
            // Then you use the index pointed to by the triangle, plus the vertex_offset, to find the correct vertex

            for (int i = 0; i < this.triangleSoups.Count; i++)
            {
                TriangleSoup currentSoup = this.triangleSoups[i];

                GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
                go.transform.parent = root.transform;

                Mesh m = new Mesh();
                go.GetComponent <MeshFilter>().mesh = m;

                int tri_count = (int)currentSoup.triangleLength / 3;
                for (int j = 0; j < tri_count; j++)
                {
                    Triangle tri = this.triangles[(int)currentSoup.triangleOffset / 3 + j];

                    for (int vert_loop = 0; vert_loop < 3; vert_loop++)
                    {
                        int offset = (int)tri.indices[vert_loop];

                        Vector3 pos = this.vertices[(int)currentSoup.vertexOffset + offset].PositionToVector3();
                        Vector2 uv  = this.vertices[(int)currentSoup.vertexOffset + offset].UVToVector2();

                        triangleIndices.Add(vertices.Count);
                        vertices.Add(pos);
                        uvs.Add(uv);
                    }
                }

                if (vertices.Count > 0)
                {
                    // Load required material here
                    Material newMat = materialCreator.CreateMaterial(materials[currentSoup.materialID].name);

                    // noDraw
                    if ((materials[currentSoup.materialID].flags & 0x0000000100000080) == 0)
                    {
                        go.SetActive(false);
                    }

                    go.GetComponent <Renderer>().material = newMat;

                    m.vertices  = vertices.ToArray();
                    m.triangles = triangleIndices.ToArray();
                    m.uv        = uvs.ToArray();

                    m.RecalculateNormals();

                    vertices.Clear();
                    triangleIndices.Clear();
                    uvs.Clear();
                }
                else
                {
                    Destroy(go);
                }
            }

            root.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);

            Destroy(gameObject);
        }