Пример #1
0
        /// <summary>
        /// Reverse the vertex order of the model
        /// </summary>
        /// <param name="wrlData">Data parsed from the wrl file</param>
        public static void ReverseVertexOrder(WrlData wrlData)
        {
            foreach (Transform transform in wrlData.TransformsList)
            {
                foreach (Shape shape in transform.ShapesList)
                {
                    if (shape.Geometry != null)
                    {
                        CoordIndexesWrl coordIndexes    = shape.Geometry.CoordIndexes;
                        CoordIndexesWrl texCoordIndexes = shape.Geometry.TexCoordIndexes;

                        if (coordIndexes != null)
                        {
                            foreach (CoordIndexWrl indexWrl in coordIndexes.IndexesList)
                            {
                                indexWrl.Indexes.Reverse();
                            }
                        }
                        if (texCoordIndexes != null)
                        {
                            foreach (CoordIndexWrl indexWrl in texCoordIndexes.IndexesList)
                            {
                                indexWrl.Indexes.Reverse();
                            }
                        }
                    }
                }
            }
        }
Пример #2
0
        private static CoordIndexesWrl CoordIndexData(string[] lines, int startIndex, int endIndex)
        {
            CoordIndexesWrl coordIndexes = new CoordIndexesWrl();

            for (int i = startIndex + 1; i < endIndex; i++)
            {
                coordIndexes.IndexesList.Add(new CoordIndexWrl(lines[i]));
            }
            return(coordIndexes);
        }
Пример #3
0
        /// <summary>
        /// Create the obj and mtl files with the given data
        /// </summary>
        /// <param name="wrlData">Data parsed from the wrl file</param>
        /// <param name="objFilename">Output file</param>
        /// <returns></returns>
        public static bool WriteObj(WrlData wrlData, string objFilename)
        {
            // objFilename has the .obj extension
            string directory   = System.IO.Path.GetDirectoryName(objFilename);
            string noExtension = System.IO.Path.GetFileNameWithoutExtension(objFilename);
            string mtlRelative = $"{noExtension}.mtl";
            string mtlFilename = System.IO.Path.Combine(directory, mtlRelative);

            List <string> mtlLines = new List <string>(); // To store the lines to append to the mtl file

            try
            {
                using (StreamWriter obj = new StreamWriter(objFilename))
                {
                    // mtllib, o, v, vt, g, usemtl, s, f

                    obj.WriteLine(GenericUtils.GetCreditsFile());
                    obj.WriteLine(ObjUtils.GetNewMtlLib(mtlRelative));

                    int i_coordIndex    = 0;
                    int i_texCoordIndex = 0;

                    int index = 0;

                    foreach (Transform transform in wrlData.TransformsList)
                    {
                        foreach (Shape shape in transform.ShapesList)
                        {
                            string groupName    = "";
                            string urlTexture   = null;
                            string diffuseColor = null;

                            if (shape.Appearance != null)
                            {
                                if (shape.Appearance.Material != null)
                                {
                                    if (shape.Appearance.Material.DiffuseColor != null)
                                    {
                                        diffuseColor = shape.Appearance.Material.DiffuseColor.ToString();
                                    }
                                }

                                if (shape.Appearance.Texture != null)
                                {
                                    urlTexture = shape.Appearance.Texture.Url;
                                    if (urlTexture != null)
                                    {
                                        groupName = ObjUtils.GetGroupName(index, urlTexture);
                                    }
                                    else
                                    {
                                        groupName = ObjUtils.GetGroupName(index);
                                    }
                                }
                                else
                                {
                                    groupName = ObjUtils.GetGroupName(index);
                                }
                            }

                            mtlLines.Add(MtlUtils.GetMtlData(groupName, urlTexture, diffuseColor));

                            obj.WriteLine(ObjUtils.GetNewObject(groupName)); // o


                            int sizeCoord = 0; int sizeTexCoord = 0;

                            if (shape.Geometry != null)
                            {
                                if (shape.Geometry.Coord != null)
                                {
                                    sizeCoord = shape.Geometry.Coord.PointsList.Count;
                                    foreach (Point point in shape.Geometry.Coord.PointsList)
                                    {
                                        obj.WriteLine(ObjUtils.GetNewCoord(point.ToString())); // v
                                    }
                                }

                                if (shape.Geometry.TexCoord != null)
                                {
                                    sizeTexCoord = shape.Geometry.TexCoord.UVList.Count;
                                    foreach (UVCoordinates uv in shape.Geometry.TexCoord.UVList)
                                    {
                                        obj.WriteLine(ObjUtils.GetNewTexCoord(uv.ToString())); // vt
                                    }
                                }
                            }

                            obj.WriteLine(ObjUtils.GetNewGroup(groupName));  // g
                            obj.WriteLine(ObjUtils.GetNewUseMtl(groupName)); // usemtl
                            obj.WriteLine(ObjUtils.GetNewSmoothGroup());     // s

                            if (shape.Geometry != null)
                            {
                                CoordIndexesWrl coordIndexes    = shape.Geometry.CoordIndexes;
                                CoordIndexesWrl texCoordIndexes = shape.Geometry.TexCoordIndexes;

                                if (coordIndexes != null)
                                {
                                    List <CoordIndexWrl> coordIndexesList = coordIndexes.IndexesList;
                                    if (texCoordIndexes != null)
                                    {
                                        List <CoordIndexWrl> texCoordIndexesList = texCoordIndexes.IndexesList;
                                        for (int i = 0; i < coordIndexesList.Count; i++)
                                        {
                                            string strIndexesF = GetIndexesF(coordIndexesList[i], texCoordIndexesList[i], i_coordIndex, i_texCoordIndex);
                                            obj.WriteLine(ObjUtils.GetNewF(strIndexesF)); // f
                                        }
                                    }
                                    else
                                    {
                                        foreach (CoordIndexWrl coordIndex in coordIndexesList)
                                        {
                                            string strIndexesF = GetIndexesF(coordIndex, i_coordIndex);
                                            obj.WriteLine(ObjUtils.GetNewF(strIndexesF)); // f
                                        }
                                    }
                                }
                            }
                            i_coordIndex    += sizeCoord;
                            i_texCoordIndex += sizeTexCoord;
                            index++;
                        }
                    }
                }
            }
            catch
            {
                return(false);
            }
            return(MtlExporter.WriteMtl(mtlLines, mtlFilename)); // Create the mtl file
        }