Ejemplo n.º 1
0
 private void ReadMaterialIndices(uint numTriangles, MeshSerialFlags serialFlags, BinaryReader reader, bool platformMismatch)
 {
     if (serialFlags.HasFlag(MeshSerialFlags.MSF_MATERIALS))
     {
         MaterialIndices = new List <ushort>((int)numTriangles);
         for (int i = 0; i < numTriangles; i++)
         {
             ushort mi = ReadWord(reader, platformMismatch);
             MaterialIndices.Add(mi);
         }
     }
     else
     {
         MaterialIndices.Clear();
     }
 }
Ejemplo n.º 2
0
        void Optimize()
        {
            needsOptimize = false;
            List <int>             meshes      = new List <int>();
            bool                   didOptimise = false;
            List <MaterialIndices> mats        = new List <MaterialIndices>();

            for (int i = StartMesh; i < endMesh; i++)
            {
                var c = counts.Where((x) => x.Material == Mesh.Meshes[i].MaterialCrc).First();
                if (c.Count == 1 || Mesh.Meshes[i].Material == null || Mesh.Meshes[i].Material.Render.IsTransparent)
                {
                    meshes.Add(i);
                }
                else
                {
                    didOptimise = true;
                    var m = mats.Where((x) => x.Crc == Mesh.Meshes[i].MaterialCrc).FirstOrDefault();
                    if (m == null)
                    {
                        m = new MaterialIndices()
                        {
                            Crc = Mesh.Meshes[i].MaterialCrc
                        };
                        mats.Add(m);
                    }
                    for (int j = Mesh.Meshes[i].TriangleStart; j < (Mesh.Meshes[i].TriangleStart + Mesh.Meshes[i].NumRefVertices); j++)
                    {
                        m.Indices.Add(Mesh.Indices[j] + StartVertex + Mesh.Meshes[i].StartVertex);
                    }
                }
            }

            if (didOptimise)
            {
                List <OptimizedDrawcall> dcs     = new List <OptimizedDrawcall>();
                List <ushort>            indices = new List <ushort>();
                foreach (var m in mats)
                {
                    var dc = new OptimizedDrawcall();
                    dc.MaterialCrc    = m.Crc;
                    dc.PrimitiveCount = m.Indices.Count / 3;
                    dc.StartIndex     = indices.Count + Mesh.IndexHandle.CountIndex;
                    var min = m.Indices.Min();
                    for (int i = 0; i < m.Indices.Count; i++)
                    {
                        indices.Add((ushort)(m.Indices[i] - min));
                    }
                    dc.VertexOffset = min + Mesh.VertexOffset;
                    dc.vMeshLibrary = vMeshLibrary;
                    dcs.Add(dc);
                }
                if (Mesh.IndexHandle.CountIndex + indices.Count >= Mesh.IndexHandle.TotalIndex)
                {
                    FLLog.Warning("Vms", "Failed to optimise: Not enough space in element buffer");
                    return;
                }
                var arr = indices.ToArray();
                mesh.IndexHandle.Elements.SetData(arr, arr.Length, Mesh.IndexHandle.CountIndex);
                mesh.IndexHandle.CountIndex += arr.Length;
                FLLog.Debug("Optimiser", "Reduced from " + MeshCount + " drawcalls to " + (meshes.Count + dcs.Count));
                optimized            = new OptimizedDraw();
                optimized.NormalDraw = meshes.ToArray();
                optimized.Optimized  = dcs.ToArray();
            }
        }
Ejemplo n.º 3
0
        public void Parse()
        {
            this.Triangle.Clear();
            this.TextureCoordinates.Clear();
            this.Vertices.Clear();
            bool newMesh = false;

            bool defaultMTL = false;
            int  mtlIndex   = 0;
            int  meshIndex  = 0;

            for (int i = 0; i < this.document.Length; i++)
            {
                string   currLine      = this.document[i].ToLower();
                int      valsInd       = 0;
                string[] spli          = currLine.Split(' ');
                bool     waitForMtlLib = false;
                bool     waitForMtl    = false;
                bool     vert          = false;
                bool     uv            = false;
                bool     triangle      = false;
                float[]  vals          = new float[3];
                string[] vals_S        = new string[3];

                for (int j = 0; j < spli.Length; j++)
                {
                    if (spli[j] == "v")
                    {
                        vert = true;
                        continue;
                    }
                    if (spli[j] == "vt")
                    {
                        uv = true;
                        continue;
                    }
                    if (newMesh)
                    {
                        if (spli[j].Length > 0)
                        {
                            int indexOf = meshNames.IndexOf(spli[j]);
                            if (spli[j].Length > 0 && indexOf < 0)
                            {
                                meshIndex = meshNames.Count;
                                this.Triangle.Add(new List <int[]>(0));
                                meshNames.Add(spli[j]);
                                MaterialIndices.Add(mtlIndex);
                            }
                            else
                            {
                                meshIndex = indexOf;
                                //MaterialIndices.Add(mtlIndex);
                            }
                        }

                        newMesh = false;
                        continue;
                    }
                    if (spli[j] == "f")
                    {
                        triangle = true;
                        continue;
                    }
                    if (spli[j] == "g")
                    {
                        newMesh = true;
                        continue;
                    }
                    if (spli[j] == "mtllib")
                    {
                        waitForMtlLib = true;
                        continue;
                    }
                    if (spli[j] == "usemtl")
                    {
                        waitForMtl = true;
                        continue;
                    }
                    if (waitForMtl)
                    {
                        if (defaultMTL)
                        {
                            int indexOf = materialNames.IndexOf(spli[j]);
                            if (indexOf < 0)
                            {
                                mtlIndex = materialNames.Count;

                                if (File.Exists(this.DirectoryName + @"\" + spli[j].Replace("/", "\\")))
                                {
                                    materialFileNames.Add(this.DirectoryName + @"\" + spli[j].Replace("/", "\\"));
                                }
                                else
                                {
                                    materialFileNames.Add(spli[j]);
                                }

                                materialNames.Add(spli[j]);
                            }
                            else
                            {
                                mtlIndex = indexOf;
                            }
                        }
                        else
                        {
                            mtlIndex = materialNames.IndexOf(spli[j]);
                        }
                        MaterialIndices[meshIndex] = mtlIndex;
                        waitForMtl = false;
                        continue;
                    }
                    if (waitForMtlLib)
                    {
                        string[] mtl = new string[0];
                        if (File.Exists(this.DirectoryName + @"\" + spli[j].Replace("/", "\\")))
                        {
                            mtl = File.ReadAllLines(this.DirectoryName + @"\" + spli[j].Replace("/", "\\"));
                        }
                        else if (File.Exists(spli[j]))
                        {
                            mtl = File.ReadAllLines(spli[j]);
                        }
                        if (mtl.Length > 0)
                        {
                            bool newMTL       = false;
                            bool waitForImage = false;
                            for (int k = 0; k < mtl.Length; k++)
                            {
                                string   currLine_ = mtl[k].ToLower();
                                string[] spli_     = currLine_.Split(' ');
                                for (int l = 0; l < spli_.Length; l++)
                                {
                                    if (spli_[l] == "newmtl")
                                    {
                                        newMTL = true;
                                        continue;
                                    }
                                    if (spli_[l] == "map_kd")
                                    {
                                        waitForImage = true;
                                        continue;
                                    }
                                    if (newMTL)
                                    {
                                        if (materialFileNames.Count < materialNames.Count)
                                        {
                                            materialFileNames.Add("noImage.png");
                                        }
                                        materialNames.Add(spli_[l]);
                                        newMTL = false;
                                    }
                                    if (waitForImage)
                                    {
                                        if (File.Exists(this.DirectoryName + @"\" + spli_[l].Replace("/", "\\")))
                                        {
                                            materialFileNames.Add(this.DirectoryName + @"\" + spli_[l].Replace("/", "\\"));
                                        }
                                        else
                                        {
                                            materialFileNames.Add(spli_[l]);
                                        }
                                        waitForImage = false;
                                    }
                                }
                            }
                        }
                        else
                        {
                            defaultMTL = true;
                        }
                        waitForMtlLib = false;
                        continue;
                    }
                    float currVal = 0;
                    if (Single.TryParse(spli[j].Replace(".", System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.NumberDecimalSeparator), out currVal))
                    {
                        vals[valsInd] = currVal;
                        valsInd++;
                    }
                    if (spli[j].Contains("/"))
                    {
                        vals_S[valsInd] = spli[j];
                        valsInd++;
                    }
                }
                if (vert)
                {
                    float x = vals[0];
                    float y = vals[1];
                    float z = vals[2];

                    if (x > this.MaxCoords.X)
                    {
                        this.MaxCoords.X = x;
                    }
                    if (x < this.MinCoords.X)
                    {
                        this.MinCoords.X = x;
                    }

                    if (y > this.MaxCoords.Y)
                    {
                        this.MaxCoords.Y = y;
                    }
                    if (y < this.MinCoords.Y)
                    {
                        this.MinCoords.Y = y;
                    }

                    if (z > this.MaxCoords.Z)
                    {
                        this.MaxCoords.Z = z;
                    }
                    if (z < this.MinCoords.Z)
                    {
                        this.MinCoords.Z = z;
                    }

                    this.Vertices.Add(new Vector3(x, y, z));
                    vert = false;
                }
                if (uv)
                {
                    this.TextureCoordinates.Add(new Vector2(vals[0], 1 - vals[1]));
                    uv = false;
                }
                if (triangle)
                {
                    for (int m = 0; m < vals_S.Length; m++)
                    {
                        string[] spli__ = vals_S[m].Split('/');
                        this.Triangle[meshIndex].Add(new int[3]);
                        for (int n = 0; n < spli__.Length; n++)
                        {
                            this.Triangle[meshIndex].Last()[n] = int.Parse(spli__[n]) - 1;
                        }
                    }
                    triangle = false;
                }
            }
            this.RenderBuffer = new VertexPositionColorTexture[this.Triangle.Count][];
            for (int i = 0; i < this.RenderBuffer.Length; i++)
            {
                this.RenderBuffer[i] = new VertexPositionColorTexture[this.Triangle[i].Count];
                for (int j = 0; j < this.RenderBuffer[i].Length; j++)
                {
                    this.RenderBuffer[i][j] = new VertexPositionColorTexture();
                }
            }
        }
Ejemplo n.º 4
0
        public void Parse()
        {
            byte[] data = SrkBinary.GetBytesArray(this.FileName);

            string fileData = Encoding.ASCII.GetString(data);

            fileData = fileData.Replace("xmlns", "whocares");
            this.Document.LoadXml(fileData);


            XmlNodeList materials = this.Document.SelectNodes("//library_materials/material");

            if (materials != null)
            {
                for (int i = 0; i < materials.Count; i++)
                {
                    string materialID = materials[i].SelectNodes("@id")[0].InnerText;
                    string effectID   = materials[i].SelectNodes("instance_effect/@url")[0].InnerText.Remove(0, 1);

                    XmlNode     effectNode   = this.Document.SelectNodes("//library_effects/effect[@id='" + effectID + "']")[0];
                    string      imageID      = "";
                    XmlNodeList surfInitNode = effectNode.SelectNodes("profile_COMMON//surface/init_from");
                    if (surfInitNode != null && surfInitNode.Count > 0)
                    {
                        imageID = surfInitNode[0].InnerText;
                    }

                    XmlNodeList textureNode = effectNode.SelectNodes("profile_COMMON//texture/@texture");
                    if (imageID.Length == 0 && textureNode != null && textureNode.Count > 0)
                    {
                        imageID = textureNode[0].InnerText;
                    }
                    string fileName = this.Document.SelectNodes("//library_images/image[@id='" + imageID + "']/init_from")[0].InnerText;
                    fileName = fileName.Replace("file://", "");
                    fileName = fileName.Replace("../", "");
                    fileName = fileName.Replace("./", "");
                    fileName = fileName.Replace("/", "\\");


                    if (Path.GetExtension(fileName).Length == 0)
                    {
                        string dir         = Path.GetDirectoryName(fileName);
                        bool   notFoundExt = true;
                        if (Directory.Exists(dir))
                        {
                            string[] dirFiles = Directory.GetFiles(dir);
                            for (int d = 0; d < dirFiles.Length; d++)
                            {
                                if (Path.GetFileNameWithoutExtension(dirFiles[d]) == Path.GetFileNameWithoutExtension(fileName))
                                {
                                    fileName   += Path.GetExtension(dirFiles[d]);
                                    notFoundExt = false;
                                    break;
                                }
                            }
                        }
                        if (notFoundExt)
                        {
                            fileName += ".png";
                        }
                    }

                    string[] spli   = fileName.Split('\\');
                    bool     exists = false;

                    string fname = "";
                    if (spli.Length > 0)
                    {
                        fileName = spli[spli.Length - 1];
                        if (File.Exists(this.DirectoryName + @"\" + fileName))
                        {
                            fname  = this.DirectoryName + @"\" + fileName;
                            exists = true;
                        }
                    }

                    if (!exists)
                    {
                        fname  = fileName;
                        exists = true;
                    }

                    this.materialNames.Add(materialID);
                    this.materialFileNames.Add(fname);
                }
            }

            var         wrapnode   = this.Document.SelectNodes("//technique[@profile='MAYA']");
            bool        wrapUV     = wrapnode != null && wrapnode.Count > 0;
            XmlNodeList geometries = this.Document.SelectNodes("//library_geometries/geometry");

            for (int i = 0; i < geometries.Count; i++)
            {
                XmlNode mesh = geometries[i].SelectNodes("mesh")[0];
                this.GeometryIDs.Add(geometries[i].SelectNodes("@id")[0].InnerText);

                XmlNodeList inputs = mesh.SelectNodes("*/input[@semantic]");


                string vertexID   = "";
                string normalID   = "";
                string texcoordID = "";
                string colorID    = "";

                vertexTriInd.Add(-1);
                normalTriInd.Add(-1);
                uvTriInd.Add(-1);
                colorTriInd.Add(-1);
                int stride = 0;
                for (int j = 0; j < inputs.Count; j++)
                {
                    string      semanticAtt = inputs[j].SelectNodes("@semantic")[0].InnerText.ToUpper();
                    XmlNodeList offsetAtt   = inputs[j].SelectNodes("@offset");

                    switch (semanticAtt)
                    {
                    case "VERTEX":
                        vertexTriInd[vertexTriInd.Count - 1] = 0;
                        if (offsetAtt != null && offsetAtt.Count > 0)
                        {
                            vertexTriInd[vertexTriInd.Count - 1] = int.Parse(offsetAtt[0].InnerText);
                            stride++;
                        }
                        break;

                    case "POSITION":
                        vertexID = inputs[j].SelectNodes("@source")[0].InnerText.Remove(0, 1);
                        break;

                    case "NORMAL":
                        normalTriInd[normalTriInd.Count - 1] = 0;
                        if (offsetAtt != null && offsetAtt.Count > 0)
                        {
                            normalTriInd[normalTriInd.Count - 1] = int.Parse(offsetAtt[0].InnerText);
                            stride++;
                        }
                        normalID = inputs[j].SelectNodes("@source")[0].InnerText.Remove(0, 1);
                        break;

                    case "TEXCOORD":
                        uvTriInd[uvTriInd.Count - 1] = 0;
                        if (offsetAtt != null && offsetAtt.Count > 0)
                        {
                            uvTriInd[uvTriInd.Count - 1] = int.Parse(offsetAtt[0].InnerText);
                            stride++;
                        }
                        texcoordID = inputs[j].SelectNodes("@source")[0].InnerText.Remove(0, 1);
                        break;

                    case "COLOR":
                        colorTriInd[colorTriInd.Count - 1] = 0;
                        if (offsetAtt != null && offsetAtt.Count > 0)
                        {
                            colorTriInd[colorTriInd.Count - 1] = int.Parse(offsetAtt[0].InnerText);
                            stride++;
                        }
                        colorID = inputs[j].SelectNodes("@source")[0].InnerText.Remove(0, 1);
                        break;
                    }
                }

                if (vertexID.Length == 0)
                {
                    throw new Exception("Error: Mesh " + i + " does not have vertices. Remove this mesh before to use this tool.");
                }

                string[] vertexArray   = new string[0];
                string[] normalArray   = new string[0];
                string[] texcoordArray = new string[0];
                string[] colorArray    = new string[0];

                if (vertexID.Length > 0)
                {
                    vertexArray = Format(mesh.SelectNodes(@"source[@id='" + vertexID + "']/float_array")[0].InnerText).Split(' ');
                }
                if (normalID.Length > 0)
                {
                    normalArray = Format(mesh.SelectNodes(@"source[@id='" + normalID + "']/float_array")[0].InnerText).Split(' ');
                }
                if (texcoordID.Length > 0)
                {
                    texcoordArray = Format(mesh.SelectNodes(@"source[@id='" + texcoordID + "']/float_array")[0].InnerText).Split(' ');
                }
                if (colorID.Length > 0)
                {
                    colorArray = Format(mesh.SelectNodes(@"source[@id='" + colorID + "']/float_array")[0].InnerText).Split(' ');
                }

                this.Vertices.Add(new List <Vector3>(0));
                this.Normal.Add(new List <Vector3>(0));
                this.TextureCoordinates.Add(new List <Vector2>(0));
                this.VertexColor.Add(new List <byte[]>(0));

                this.Triangle.Add(new List <int[]>(0));

                this.Influences.Add(new List <List <float> >(0));
                this.InfluencesIndices.Add(new List <List <int> >(0));

                for (int j = 0; j < vertexArray.Length; j += 3)
                {
                    float x = Single.Parse(vertexArray[j]);
                    float y = Single.Parse(vertexArray[j + 1]);
                    float z = Single.Parse(vertexArray[j + 2]);

                    if (x > this.MaxCoords.X)
                    {
                        this.MaxCoords.X = x;
                    }
                    if (x < this.MinCoords.X)
                    {
                        this.MinCoords.X = x;
                    }

                    if (y > this.MaxCoords.Y)
                    {
                        this.MaxCoords.Y = y;
                    }
                    if (y < this.MinCoords.Y)
                    {
                        this.MinCoords.Y = y;
                    }

                    if (z > this.MaxCoords.Z)
                    {
                        this.MaxCoords.Z = z;
                    }
                    if (z < this.MinCoords.Z)
                    {
                        this.MinCoords.Z = z;
                    }

                    this.Vertices.Last().Add(new Vector3(x, y, z));
                }

                for (int j = 0; j < normalArray.Length; j += 3)
                {
                    this.Normal.Last().Add(new Vector3(Single.Parse(normalArray[j]), Single.Parse(normalArray[j + 1]), Single.Parse(normalArray[j + 2])));
                }

                for (int j = 0; j < texcoordArray.Length; j += 2)
                {
                    Vector2 uv = new Vector2(Single.Parse(texcoordArray[j]), 1 - Single.Parse(texcoordArray[j + 1]));
                    this.TextureCoordinates.Last().Add(uv);
                }

                for (int j = 0; j < colorArray.Length; j += 4)
                {
                    this.VertexColor.Last().Add(new byte[] {
                        (byte)(Single.Parse(colorArray[j]) * 128),
                        (byte)(Single.Parse(colorArray[j + 1]) * 128),
                        (byte)(Single.Parse(colorArray[j + 2]) * 128),
                        (byte)(Single.Parse(colorArray[j + 3]) * 128)
                    });
                }

                string triangleString = mesh.SelectNodes(@"triangles/p")[0].InnerText;

                string[] triangleArray = Format(triangleString).Split(' ');
                for (int j = 0; j < triangleArray.Length; j += stride)
                {
                    int[] indices = new int[stride];
                    for (int k = 0; k < stride; k++)
                    {
                        indices[k] = int.Parse(triangleArray[j + k]);
                    }

                    this.Triangle.Last().Add(indices);
                }
            }

            var bonesNode = this.Document.SelectNodes(@"//library_visual_scenes/visual_scene//node[@type='JOINT']"); // and not(contains(@name,'mesh'))

            if (bonesNode != null && bonesNode.Count > 0)
            {
                this.Skeleton.Bones           = new Bone[bonesNode.Count];
                this.Skeleton.BonesMatrices   = new Matrix[bonesNode.Count];
                this.Skeleton.BonesReMatrices = new Matrix[bonesNode.Count];

                bonesNode = this.Document.SelectNodes(@"//library_visual_scenes/visual_scene/node[@type='JOINT']");
                for (int i = 0; i < bonesNode.Count; i++)
                {
                    XmlNode bone000 = bonesNode[i];
                    GetBoneNames(bone000);
                    GetBones(bone000);
                    UnwrapSkeleton(bone000, -1);
                }
                ComputeMatrices();
            }

            XmlNodeList skinnings = this.Document.SelectNodes(@"//library_controllers/controller/skin");

            for (int i = 0; i < skinnings.Count; i++)
            {
                var sourceNodes = skinnings[i].SelectNodes("@source");
                if (sourceNodes == null || sourceNodes.Count == 0)
                {
                    continue;
                }
                int geometryIndex = this.GeometryIDs.IndexOf(sourceNodes[0].InnerText.Remove(0, 1));
                if (geometryIndex < 0)
                {
                    continue;
                }

                string   jointID      = skinnings[i].SelectNodes(@"*/input[@semantic='JOINT']/@source")[0].InnerText.Remove(0, 1);
                string[] jointsArray  = Format(skinnings[i].SelectNodes(@"source[@id='" + jointID + "']/Name_array")[0].InnerText).Split(' ');
                string[] skinCounts   = Format(skinnings[i].SelectNodes(@"vertex_weights/vcount")[0].InnerText).Split(' ');
                string[] skins        = Format(skinnings[i].SelectNodes(@"vertex_weights/v")[0].InnerText).Split(' ');
                string[] skinsWeights = Format(skinnings[i].SelectNodes(@"source[contains(@id, 'eights')]/float_array")[0].InnerText).Split(' ');

                int tabIndex = 0;

                for (int j = 0; j < skinCounts.Length; j++)
                {
                    int influenceCount = int.Parse(skinCounts[j]);

                    this.Influences[geometryIndex].Add(new List <float>(0));
                    this.InfluencesIndices[geometryIndex].Add(new List <int>(0));

                    for (int k = 0; k < influenceCount; k++)
                    {
                        int   jointIndex  = int.Parse(skins[tabIndex]);
                        int   weightIndex = int.Parse(skins[tabIndex + 1]);
                        float weight      = Single.Parse(skinsWeights[weightIndex]);

                        string jointName = jointsArray[jointIndex];

                        this.Influences[geometryIndex].Last().Add(weight);
                        this.InfluencesIndices[geometryIndex].Last().Add(BoneNames.IndexOf(jointName));

                        tabIndex += 2;
                    }
                }
            }

            List <string> materialsFnames = new List <string>(0);

            for (int i = 0; i < this.Triangle.Count; i++)
            {
                string currController = "";
                for (int l = 0; l < skinnings.Count; l++)
                {
                    var node = skinnings[l].SelectNodes("@source");
                    if (node != null && node.Count > 0 && node[0].InnerText == "#" + this.GeometryIDs[i])
                    {
                        node = skinnings[l].ParentNode.SelectNodes("@id");
                        if (node != null && node.Count > 0)
                        {
                            currController = node[0].InnerText;
                            break;
                        }
                    }
                }
                string matID = "";
                if (matID.Length == 0)
                {
                    XmlNodeList instanceGeometry = this.Document.SelectNodes("//library_visual_scenes/visual_scene/node/instance_geometry[@url='#" + GeometryIDs[i] + "']//instance_material/@target");
                    if (instanceGeometry != null && instanceGeometry.Count > 0)
                    {
                        matID = instanceGeometry[0].InnerText.Remove(0, 1);
                        if (!materialNames.Contains(matID))
                        {
                            matID = "";
                        }
                    }
                }
                if (matID.Length == 0)
                {
                    XmlNodeList instanceController = this.Document.SelectNodes("//library_visual_scenes/visual_scene/node/instance_controller[@url='#" + currController + "']//instance_material/@target");
                    if (instanceController != null && instanceController.Count > 0)
                    {
                        matID = instanceController[0].InnerText.Remove(0, 1);
                        if (!materialNames.Contains(matID))
                        {
                            matID = "";
                        }
                    }
                }

                if (matID.Length > 0)
                {
                    string fname          = materialFileNames[materialNames.IndexOf(matID)];
                    int    mmaterialIndex = materialsFnames.Count;

                    if (!materialsFnames.Contains(fname))
                    {
                        materialsFnames.Add(fname);
                    }
                    else
                    {
                        mmaterialIndex = materialsFnames.IndexOf(fname);
                    }
                    MaterialIndices.Add(mmaterialIndex);
                }
            }
            this.RenderBuffer = new VertexPositionColorTexture[this.Triangle.Count][];
            for (int i = 0; i < this.RenderBuffer.Length; i++)
            {
                this.RenderBuffer[i] = new VertexPositionColorTexture[this.Triangle[i].Count];
                for (int j = 0; j < this.RenderBuffer[i].Length; j++)
                {
                    this.RenderBuffer[i][j] = new VertexPositionColorTexture();
                }
            }
        }