< Summary

Information
Class: JeremyAnsel.Media.WavefrontObj.ObjFileWriter
Assembly: JeremyAnsel.Media.WavefrontObj
File(s): https://raw.githubusercontent.com/JeremyAnsel/JeremyAnsel.Media.WavefrontObj/7b5b951766c69f14731a856f32198cdbf1fc6847/JeremyAnsel.Media.WavefrontObj/JeremyAnsel.Media.WavefrontObj/ObjFileWriter.cs
Line coverage
100%
Covered lines: 231
Uncovered lines: 0
Coverable lines: 231
Total lines: 458
Line coverage: 100%
Branch coverage
100%
Covered branches: 86
Total branches: 86
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
Write(...)100%11100%
WriteHeaderText(...)100%44100%
WriteShadowObjectFileName(...)100%22100%
WriteTraceObjectFileName(...)100%22100%
WriteMapLibraries(...)100%44100%
WriteMaterialLibraries(...)100%44100%
WriteVertices(...)100%88100%
WriteParameterSpaceVertices(...)100%66100%
WriteVertexNormals(...)100%22100%
WriteTextureVertices(...)100%22100%
WriteSurfaceConnection(...)100%22100%
WritePoints(...)100%44100%
WriteLines(...)100%44100%
WriteFaces(...)100%44100%
WriteCurves(...)100%44100%
WriteCurves2D(...)100%44100%
WriteSurfaces(...)100%44100%
WriteBodyOfFreeFormElement(...)100%2626100%

File(s)

https://raw.githubusercontent.com/JeremyAnsel/JeremyAnsel.Media.WavefrontObj/7b5b951766c69f14731a856f32198cdbf1fc6847/JeremyAnsel.Media.WavefrontObj/JeremyAnsel.Media.WavefrontObj/ObjFileWriter.cs

#LineLine coverage
 1// <copyright file="ObjFileWriter.cs" company="Jérémy Ansel">
 2// Copyright (c) 2017, 2019 Jérémy Ansel
 3// </copyright>
 4// <license>
 5// Licensed under the MIT license. See LICENSE.txt
 6// </license>
 7
 8using System.Globalization;
 9
 10namespace JeremyAnsel.Media.WavefrontObj
 11{
 12    internal static class ObjFileWriter
 13    {
 14        public static void Write(ObjFile obj, StreamWriter stream)
 15        {
 28816            var context = new ObjFileWriterContext(obj);
 17
 28818            WriteHeaderText(obj, stream);
 19
 28820            WriteShadowObjectFileName(obj, stream);
 28821            WriteTraceObjectFileName(obj, stream);
 22
 28823            WriteMapLibraries(obj, stream);
 28824            WriteMaterialLibraries(obj, stream);
 25
 28826            WriteVertices(obj, stream);
 28827            WriteParameterSpaceVertices(obj, stream);
 28828            WriteVertexNormals(obj, stream);
 28829            WriteTextureVertices(obj, stream);
 30
 28831            WritePoints(obj, stream, context);
 28832            WriteLines(obj, stream, context);
 28833            WriteFaces(obj, stream, context);
 34
 28835            WriteCurves(obj, stream, context);
 28836            WriteCurves2D(obj, stream, context);
 28837            WriteSurfaces(obj, stream, context);
 38
 28839            WriteSurfaceConnection(obj, stream);
 28840        }
 41
 42        private static void WriteHeaderText(ObjFile obj, StreamWriter stream)
 43        {
 28844            if (string.IsNullOrEmpty(obj.HeaderText))
 45            {
 28446                return;
 47            }
 48
 449            string[] headerLines = obj.HeaderText!.Split('\n');
 50
 2451            foreach (string line in headerLines)
 52            {
 853                stream.Write('#');
 854                stream.WriteLine(line);
 55            }
 456        }
 57
 58        private static void WriteShadowObjectFileName(ObjFile obj, StreamWriter stream)
 59        {
 28860            if (!string.IsNullOrEmpty(obj.ShadowObjectFileName))
 61            {
 1262                stream.Write(string.Format(CultureInfo.InvariantCulture, "shadow_obj {0}\n", obj.ShadowObjectFileName));
 63            }
 28864        }
 65
 66        private static void WriteTraceObjectFileName(ObjFile obj, StreamWriter stream)
 67        {
 28868            if (!string.IsNullOrEmpty(obj.TraceObjectFileName))
 69            {
 470                stream.Write(string.Format(CultureInfo.InvariantCulture, "trace_obj {0}\n", obj.TraceObjectFileName));
 71            }
 28872        }
 73
 74        private static void WriteMapLibraries(ObjFile obj, StreamWriter stream)
 75        {
 28876            if (obj.MapLibraries.Count == 0)
 77            {
 28478                return;
 79            }
 80
 481            stream.Write("maplib");
 82
 2483            foreach (string map in obj.MapLibraries)
 84            {
 885                stream.Write(" ");
 886                stream.Write(map);
 87            }
 88
 489            stream.WriteLine();
 490        }
 91
 92        private static void WriteMaterialLibraries(ObjFile obj, StreamWriter stream)
 93        {
 28894            if (obj.MaterialLibraries.Count == 0)
 95            {
 28496                return;
 97            }
 98
 499            stream.Write("mtllib");
 100
 24101            foreach (string map in obj.MaterialLibraries)
 102            {
 8103                stream.Write(" ");
 8104                stream.Write(map);
 105            }
 106
 4107            stream.WriteLine();
 4108        }
 109
 110        private static void WriteVertices(ObjFile obj, StreamWriter stream)
 111        {
 776112            foreach (var vertex in obj.Vertices)
 113            {
 100114                var position = vertex.Position;
 115
 100116                if (vertex.Color.HasValue)
 117                {
 8118                    var color = vertex.Color.Value;
 119
 8120                    if (color.W == 1.0f)
 121                    {
 4122                        stream.WriteLine(
 4123                            "v {0} {1} {2} {3} {4} {5}",
 4124                            position.X.ToString("F6", CultureInfo.InvariantCulture),
 4125                            position.Y.ToString("F6", CultureInfo.InvariantCulture),
 4126                            position.Z.ToString("F6", CultureInfo.InvariantCulture),
 4127                            color.X.ToString("F6", CultureInfo.InvariantCulture),
 4128                            color.Y.ToString("F6", CultureInfo.InvariantCulture),
 4129                            color.Z.ToString("F6", CultureInfo.InvariantCulture));
 130                    }
 131                    else
 132                    {
 4133                        stream.WriteLine(
 4134                            "v {0} {1} {2} {3} {4} {5} {6}",
 4135                            position.X.ToString("F6", CultureInfo.InvariantCulture),
 4136                            position.Y.ToString("F6", CultureInfo.InvariantCulture),
 4137                            position.Z.ToString("F6", CultureInfo.InvariantCulture),
 4138                            color.X.ToString("F6", CultureInfo.InvariantCulture),
 4139                            color.Y.ToString("F6", CultureInfo.InvariantCulture),
 4140                            color.Z.ToString("F6", CultureInfo.InvariantCulture),
 4141                            color.W.ToString("F6", CultureInfo.InvariantCulture));
 142                    }
 143                }
 144                else
 145                {
 92146                    if (position.W == 1.0f)
 147                    {
 88148                        stream.WriteLine(
 88149                            "v {0} {1} {2}",
 88150                            position.X.ToString("F6", CultureInfo.InvariantCulture),
 88151                            position.Y.ToString("F6", CultureInfo.InvariantCulture),
 88152                            position.Z.ToString("F6", CultureInfo.InvariantCulture));
 153                    }
 154                    else
 155                    {
 4156                        stream.WriteLine(
 4157                            "v {0} {1} {2} {3}",
 4158                            position.X.ToString("F6", CultureInfo.InvariantCulture),
 4159                            position.Y.ToString("F6", CultureInfo.InvariantCulture),
 4160                            position.Z.ToString("F6", CultureInfo.InvariantCulture),
 4161                            position.W.ToString("F6", CultureInfo.InvariantCulture));
 162                    }
 163                }
 164            }
 288165        }
 166
 167        private static void WriteParameterSpaceVertices(ObjFile obj, StreamWriter stream)
 168        {
 632169            foreach (var vertex in obj.ParameterSpaceVertices)
 170            {
 28171                if (vertex.Z == 1.0f)
 172                {
 8173                    if (vertex.Y == 0.0f)
 174                    {
 4175                        stream.WriteLine(
 4176                            "vp {0}",
 4177                            vertex.X.ToString("F6", CultureInfo.InvariantCulture));
 178                    }
 179                    else
 180                    {
 4181                        stream.WriteLine(
 4182                            "vp {0} {1}",
 4183                            vertex.X.ToString("F6", CultureInfo.InvariantCulture),
 4184                            vertex.Y.ToString("F6", CultureInfo.InvariantCulture));
 185                    }
 186                }
 187                else
 188                {
 20189                    stream.WriteLine(
 20190                        "vp {0} {1} {2}",
 20191                        vertex.X.ToString("F6", CultureInfo.InvariantCulture),
 20192                        vertex.Y.ToString("F6", CultureInfo.InvariantCulture),
 20193                        vertex.Z.ToString("F6", CultureInfo.InvariantCulture));
 194                }
 195            }
 288196        }
 197
 198        private static void WriteVertexNormals(ObjFile obj, StreamWriter stream)
 199        {
 584200            foreach (var vertex in obj.VertexNormals)
 201            {
 4202                stream.WriteLine(
 4203                    "vn {0} {1} {2}",
 4204                    vertex.X.ToString("F6", CultureInfo.InvariantCulture),
 4205                    vertex.Y.ToString("F6", CultureInfo.InvariantCulture),
 4206                    vertex.Z.ToString("F6", CultureInfo.InvariantCulture));
 207            }
 288208        }
 209
 210        private static void WriteTextureVertices(ObjFile obj, StreamWriter stream)
 211        {
 600212            foreach (var vertex in obj.TextureVertices)
 213            {
 12214                stream.WriteLine(
 12215                    "vt {0} {1} {2}",
 12216                    vertex.X.ToString("F6", CultureInfo.InvariantCulture),
 12217                    vertex.Y.ToString("F6", CultureInfo.InvariantCulture),
 12218                    vertex.Z.ToString("F6", CultureInfo.InvariantCulture));
 219            }
 288220        }
 221
 222        private static void WriteSurfaceConnection(ObjFile obj, StreamWriter stream)
 223        {
 584224            foreach (ObjSurfaceConnection con in obj.SurfaceConnections)
 225            {
 4226                stream.WriteLine("con {0} {1} {2} {3}",
 4227                    con.Surface1.ToString(CultureInfo.InvariantCulture),
 4228                    con.Curve2D1.ToString(),
 4229                    con.Surface2.ToString(CultureInfo.InvariantCulture),
 4230                    con.Curve2D2.ToString());
 231            }
 288232        }
 233
 234        private static void WritePoints(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 235        {
 792236            foreach (ObjPoint point in obj.Points)
 237            {
 136238                context.WriteGroupNames(stream, point, g => g.Points);
 108239                context.WriteAttributesOfElement(stream, point);
 108240                context.WriteAttributesOfPolygonalElement(stream, point);
 241
 108242                stream.Write("p");
 243
 440244                foreach (ObjTriplet vertex in point.Vertices)
 245                {
 112246                    stream.Write(" {0}", vertex);
 247                }
 248
 108249                stream.WriteLine();
 250            }
 288251        }
 252
 253        private static void WriteLines(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 254        {
 584255            foreach (ObjLine line in obj.Lines)
 256            {
 8257                context.WriteGroupNames(stream, line, g => g.Lines);
 4258                context.WriteAttributesOfElement(stream, line);
 4259                context.WriteAttributesOfPolygonalElement(stream, line);
 260
 4261                stream.Write("l");
 262
 32263                foreach (ObjTriplet vertex in line.Vertices)
 264                {
 12265                    stream.Write(" {0}", vertex);
 266                }
 267
 4268                stream.WriteLine();
 269            }
 288270        }
 271
 272        private static void WriteFaces(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 273        {
 584274            foreach (ObjFace face in obj.Faces)
 275            {
 8276                context.WriteGroupNames(stream, face, g => g.Faces);
 4277                context.WriteAttributesOfElement(stream, face);
 4278                context.WriteAttributesOfPolygonalElement(stream, face);
 279
 4280                stream.Write("f");
 281
 48282                foreach (ObjTriplet vertex in face.Vertices)
 283                {
 20284                    stream.Write(" {0}", vertex);
 285                }
 286
 4287                stream.WriteLine();
 288            }
 288289        }
 290
 291        private static void WriteCurves(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 292        {
 848293            foreach (ObjCurve curve in obj.Curves)
 294            {
 140295                context.WriteGroupNames(stream, curve, g => g.Curves);
 136296                context.WriteAttributesOfElement(stream, curve);
 136297                context.WriteAttributesOfFreeFormElement(stream, curve);
 298
 136299                stream.Write("curv {0} {1}",
 136300                    curve.StartParameter.ToString("F6", CultureInfo.InvariantCulture),
 136301                    curve.EndParameter.ToString("F6", CultureInfo.InvariantCulture));
 302
 1088303                foreach (int vertex in curve.Vertices)
 304                {
 408305                    stream.Write(' ');
 408306                    stream.Write(vertex);
 307                }
 308
 136309                stream.WriteLine();
 310
 136311                WriteBodyOfFreeFormElement(stream, curve);
 312            }
 288313        }
 314
 315        private static void WriteCurves2D(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 316        {
 584317            foreach (ObjCurve2D curve in obj.Curves2D)
 318            {
 8319                context.WriteGroupNames(stream, curve, g => g.Curves2D);
 4320                context.WriteAttributesOfElement(stream, curve);
 4321                context.WriteAttributesOfFreeFormElement(stream, curve);
 322
 4323                stream.Write("curv2");
 324
 32325                foreach (int vertex in curve.ParameterSpaceVertices)
 326                {
 12327                    stream.Write(' ');
 12328                    stream.Write(vertex);
 329                }
 330
 4331                stream.WriteLine();
 332
 4333                WriteBodyOfFreeFormElement(stream, curve);
 334            }
 288335        }
 336
 337        private static void WriteSurfaces(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 338        {
 584339            foreach (ObjSurface surface in obj.Surfaces)
 340            {
 8341                context.WriteGroupNames(stream, surface, g => g.Surfaces);
 4342                context.WriteAttributesOfElement(stream, surface);
 4343                context.WriteAttributesOfFreeFormElement(stream, surface);
 344
 4345                stream.Write("surf {0} {1} {2} {3}",
 4346                    surface.StartParameterU.ToString("F6", CultureInfo.InvariantCulture),
 4347                    surface.EndParameterU.ToString("F6", CultureInfo.InvariantCulture),
 4348                    surface.StartParameterV.ToString("F6", CultureInfo.InvariantCulture),
 4349                    surface.EndParameterV.ToString("F6", CultureInfo.InvariantCulture));
 350
 32351                foreach (ObjTriplet vertex in surface.Vertices)
 352                {
 12353                    stream.Write(' ');
 12354                    stream.Write(vertex);
 355                }
 356
 4357                stream.WriteLine();
 358
 4359                WriteBodyOfFreeFormElement(stream, surface);
 360            }
 288361        }
 362
 363        private static void WriteBodyOfFreeFormElement(StreamWriter stream, ObjFreeFormElement element)
 364        {
 144365            bool writeEnd = false;
 366
 144367            if (element.ParametersU.Count != 0)
 368            {
 4369                writeEnd = true;
 4370                stream.Write("parm u");
 371
 32372                foreach (float value in element.ParametersU)
 373                {
 12374                    stream.Write(' ');
 12375                    stream.Write(value.ToString("F6", CultureInfo.InvariantCulture));
 376                }
 377
 4378                stream.WriteLine();
 379            }
 380
 144381            if (element.ParametersV.Count != 0)
 382            {
 4383                writeEnd = true;
 4384                stream.Write("parm v");
 385
 32386                foreach (float value in element.ParametersV)
 387                {
 12388                    stream.Write(' ');
 12389                    stream.Write(value.ToString("F6", CultureInfo.InvariantCulture));
 390                }
 391
 4392                stream.WriteLine();
 393            }
 394
 144395            if (element.OuterTrimmingCurves.Count != 0)
 396            {
 4397                writeEnd = true;
 4398                stream.Write("trim");
 399
 24400                foreach (ObjCurveIndex index in element.OuterTrimmingCurves)
 401                {
 8402                    stream.Write(' ');
 8403                    stream.Write(index);
 404                }
 405
 4406                stream.WriteLine();
 407            }
 408
 144409            if (element.InnerTrimmingCurves.Count != 0)
 410            {
 4411                writeEnd = true;
 4412                stream.Write("hole");
 413
 24414                foreach (ObjCurveIndex index in element.InnerTrimmingCurves)
 415                {
 8416                    stream.Write(' ');
 8417                    stream.Write(index);
 418                }
 419
 4420                stream.WriteLine();
 421            }
 422
 144423            if (element.SequenceCurves.Count != 0)
 424            {
 4425                writeEnd = true;
 4426                stream.Write("scrv");
 427
 24428                foreach (ObjCurveIndex index in element.SequenceCurves)
 429                {
 8430                    stream.Write(' ');
 8431                    stream.Write(index);
 432                }
 433
 4434                stream.WriteLine();
 435            }
 436
 144437            if (element.SpecialPoints.Count != 0)
 438            {
 4439                writeEnd = true;
 4440                stream.Write("sp");
 441
 24442                foreach (int point in element.SpecialPoints)
 443                {
 8444                    stream.Write(' ');
 8445                    stream.Write(point);
 446                }
 447
 4448                stream.WriteLine();
 449            }
 450
 144451            if (writeEnd)
 452            {
 24453                stream.WriteLine("end");
 454            }
 144455        }
 456    }
 457}
 458
Generated by: ReportGenerator 5.4.18.0
11/10/2025 - 5:27:50 PM
GitHub | reportgenerator.io

Methods/Properties

Write(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteHeaderText(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteShadowObjectFileName(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteTraceObjectFileName(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteMapLibraries(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteMaterialLibraries(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteVertices(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteParameterSpaceVertices(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteVertexNormals(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteTextureVertices(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WriteSurfaceConnection(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter)
WritePoints(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFileWriterContext)
WriteLines(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFileWriterContext)
WriteFaces(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFileWriterContext)
WriteCurves(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFileWriterContext)
WriteCurves2D(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFileWriterContext)
WriteSurfaces(JeremyAnsel.Media.WavefrontObj.ObjFile,System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFileWriterContext)
WriteBodyOfFreeFormElement(System.IO.StreamWriter,JeremyAnsel.Media.WavefrontObj.ObjFreeFormElement)