< Summary

Information
Class: JeremyAnsel.Media.WavefrontObj.ObjFileWriter
Assembly: JeremyAnsel.Media.WavefrontObj
File(s): C:\projects\jeremyansel-media-wavefrontobj\JeremyAnsel.Media.WavefrontObj\JeremyAnsel.Media.WavefrontObj\ObjFileWriter.cs
Line coverage
100%
Covered lines: 231
Uncovered lines: 0
Coverable lines: 231
Total lines: 456
Line coverage: 100%
Branch coverage
100%
Covered branches: 98
Total branches: 98
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%66100%
WriteLines(...)100%66100%
WriteFaces(...)100%66100%
WriteCurves(...)100%66100%
WriteCurves2D(...)100%66100%
WriteSurfaces(...)100%66100%
WriteBodyOfFreeFormElement(...)100%2626100%

File(s)

C:\projects\jeremyansel-media-wavefrontobj\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
 12internal static class ObjFileWriter
 13{
 14    public static void Write(ObjFile obj, StreamWriter stream)
 15    {
 416        var context = new ObjFileWriterContext(obj);
 17
 418        WriteHeaderText(obj, stream);
 19
 420        WriteShadowObjectFileName(obj, stream);
 421        WriteTraceObjectFileName(obj, stream);
 22
 423        WriteMapLibraries(obj, stream);
 424        WriteMaterialLibraries(obj, stream);
 25
 426        WriteVertices(obj, stream);
 427        WriteParameterSpaceVertices(obj, stream);
 428        WriteVertexNormals(obj, stream);
 429        WriteTextureVertices(obj, stream);
 30
 431        WritePoints(obj, stream, context);
 432        WriteLines(obj, stream, context);
 433        WriteFaces(obj, stream, context);
 34
 435        WriteCurves(obj, stream, context);
 436        WriteCurves2D(obj, stream, context);
 437        WriteSurfaces(obj, stream, context);
 38
 439        WriteSurfaceConnection(obj, stream);
 440    }
 41
 42    private static void WriteHeaderText(ObjFile obj, StreamWriter stream)
 43    {
 444        if (string.IsNullOrEmpty(obj.HeaderText))
 45        {
 446            return;
 47        }
 48
 449        string[] headerLines = obj.HeaderText!.Split('\n');
 50
 451        foreach (string line in headerLines)
 52        {
 453            stream.Write('#');
 454            stream.WriteLine(line);
 55        }
 456    }
 57
 58    private static void WriteShadowObjectFileName(ObjFile obj, StreamWriter stream)
 59    {
 460        if (!string.IsNullOrEmpty(obj.ShadowObjectFileName))
 61        {
 462            stream.Write(string.Format(CultureInfo.InvariantCulture, "shadow_obj {0}\n", obj.ShadowObjectFileName));
 63        }
 464    }
 65
 66    private static void WriteTraceObjectFileName(ObjFile obj, StreamWriter stream)
 67    {
 468        if (!string.IsNullOrEmpty(obj.TraceObjectFileName))
 69        {
 470            stream.Write(string.Format(CultureInfo.InvariantCulture, "trace_obj {0}\n", obj.TraceObjectFileName));
 71        }
 472    }
 73
 74    private static void WriteMapLibraries(ObjFile obj, StreamWriter stream)
 75    {
 476        if (obj.MapLibraries.Count == 0)
 77        {
 478            return;
 79        }
 80
 481        stream.Write("maplib");
 82
 483        foreach (string map in obj.MapLibraries)
 84        {
 485            stream.Write(" ");
 486            stream.Write(map);
 87        }
 88
 489        stream.WriteLine();
 490    }
 91
 92    private static void WriteMaterialLibraries(ObjFile obj, StreamWriter stream)
 93    {
 494        if (obj.MaterialLibraries.Count == 0)
 95        {
 496            return;
 97        }
 98
 499        stream.Write("mtllib");
 100
 4101        foreach (string map in obj.MaterialLibraries)
 102        {
 4103            stream.Write(" ");
 4104            stream.Write(map);
 105        }
 106
 4107        stream.WriteLine();
 4108    }
 109
 110    private static void WriteVertices(ObjFile obj, StreamWriter stream)
 111    {
 4112        foreach (var vertex in obj.Vertices)
 113        {
 4114            var position = vertex.Position;
 115
 4116            if (vertex.Color.HasValue)
 117            {
 4118                var color = vertex.Color.Value;
 119
 4120                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            {
 4146                if (position.W == 1.0f)
 147                {
 4148                    stream.WriteLine(
 4149                        "v {0} {1} {2}",
 4150                        position.X.ToString("F6", CultureInfo.InvariantCulture),
 4151                        position.Y.ToString("F6", CultureInfo.InvariantCulture),
 4152                        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        }
 4165    }
 166
 167    private static void WriteParameterSpaceVertices(ObjFile obj, StreamWriter stream)
 168    {
 4169        foreach (var vertex in obj.ParameterSpaceVertices)
 170        {
 4171            if (vertex.Z == 1.0f)
 172            {
 4173                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            {
 4189                stream.WriteLine(
 4190                    "vp {0} {1} {2}",
 4191                    vertex.X.ToString("F6", CultureInfo.InvariantCulture),
 4192                    vertex.Y.ToString("F6", CultureInfo.InvariantCulture),
 4193                    vertex.Z.ToString("F6", CultureInfo.InvariantCulture));
 194            }
 195        }
 4196    }
 197
 198    private static void WriteVertexNormals(ObjFile obj, StreamWriter stream)
 199    {
 4200        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        }
 4208    }
 209
 210    private static void WriteTextureVertices(ObjFile obj, StreamWriter stream)
 211    {
 4212        foreach (var vertex in obj.TextureVertices)
 213        {
 4214            stream.WriteLine(
 4215                "vt {0} {1} {2}",
 4216                vertex.X.ToString("F6", CultureInfo.InvariantCulture),
 4217                vertex.Y.ToString("F6", CultureInfo.InvariantCulture),
 4218                vertex.Z.ToString("F6", CultureInfo.InvariantCulture));
 219        }
 4220    }
 221
 222    private static void WriteSurfaceConnection(ObjFile obj, StreamWriter stream)
 223    {
 4224        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        }
 4232    }
 233
 234    private static void WritePoints(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 235    {
 4236        foreach (ObjPoint point in obj.Points)
 237        {
 4238            context.WriteGroupNames(stream, point, g => g.Points);
 4239            context.WriteAttributesOfElement(stream, point);
 4240            context.WriteAttributesOfPolygonalElement(stream, point);
 241
 4242            stream.Write("p");
 243
 4244            foreach (ObjTriplet vertex in point.Vertices)
 245            {
 4246                stream.Write(" {0}", vertex);
 247            }
 248
 4249            stream.WriteLine();
 250        }
 4251    }
 252
 253    private static void WriteLines(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 254    {
 4255        foreach (ObjLine line in obj.Lines)
 256        {
 4257            context.WriteGroupNames(stream, line, g => g.Lines);
 4258            context.WriteAttributesOfElement(stream, line);
 4259            context.WriteAttributesOfPolygonalElement(stream, line);
 260
 4261            stream.Write("l");
 262
 4263            foreach (ObjTriplet vertex in line.Vertices)
 264            {
 4265                stream.Write(" {0}", vertex);
 266            }
 267
 4268            stream.WriteLine();
 269        }
 4270    }
 271
 272    private static void WriteFaces(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 273    {
 4274        foreach (ObjFace face in obj.Faces)
 275        {
 4276            context.WriteGroupNames(stream, face, g => g.Faces);
 4277            context.WriteAttributesOfElement(stream, face);
 4278            context.WriteAttributesOfPolygonalElement(stream, face);
 279
 4280            stream.Write("f");
 281
 4282            foreach (ObjTriplet vertex in face.Vertices)
 283            {
 4284                stream.Write(" {0}", vertex);
 285            }
 286
 4287            stream.WriteLine();
 288        }
 4289    }
 290
 291    private static void WriteCurves(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 292    {
 4293        foreach (ObjCurve curve in obj.Curves)
 294        {
 4295            context.WriteGroupNames(stream, curve, g => g.Curves);
 4296            context.WriteAttributesOfElement(stream, curve);
 4297            context.WriteAttributesOfFreeFormElement(stream, curve);
 298
 4299            stream.Write("curv {0} {1}",
 4300                curve.StartParameter.ToString("F6", CultureInfo.InvariantCulture),
 4301                curve.EndParameter.ToString("F6", CultureInfo.InvariantCulture));
 302
 4303            foreach (int vertex in curve.Vertices)
 304            {
 4305                stream.Write(' ');
 4306                stream.Write(vertex);
 307            }
 308
 4309            stream.WriteLine();
 310
 4311            WriteBodyOfFreeFormElement(stream, curve);
 312        }
 4313    }
 314
 315    private static void WriteCurves2D(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 316    {
 4317        foreach (ObjCurve2D curve in obj.Curves2D)
 318        {
 4319            context.WriteGroupNames(stream, curve, g => g.Curves2D);
 4320            context.WriteAttributesOfElement(stream, curve);
 4321            context.WriteAttributesOfFreeFormElement(stream, curve);
 322
 4323            stream.Write("curv2");
 324
 4325            foreach (int vertex in curve.ParameterSpaceVertices)
 326            {
 4327                stream.Write(' ');
 4328                stream.Write(vertex);
 329            }
 330
 4331            stream.WriteLine();
 332
 4333            WriteBodyOfFreeFormElement(stream, curve);
 334        }
 4335    }
 336
 337    private static void WriteSurfaces(ObjFile obj, StreamWriter stream, ObjFileWriterContext context)
 338    {
 4339        foreach (ObjSurface surface in obj.Surfaces)
 340        {
 4341            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
 4351            foreach (ObjTriplet vertex in surface.Vertices)
 352            {
 4353                stream.Write(' ');
 4354                stream.Write(vertex);
 355            }
 356
 4357            stream.WriteLine();
 358
 4359            WriteBodyOfFreeFormElement(stream, surface);
 360        }
 4361    }
 362
 363    private static void WriteBodyOfFreeFormElement(StreamWriter stream, ObjFreeFormElement element)
 364    {
 4365        bool writeEnd = false;
 366
 4367        if (element.ParametersU.Count != 0)
 368        {
 4369            writeEnd = true;
 4370            stream.Write("parm u");
 371
 4372            foreach (float value in element.ParametersU)
 373            {
 4374                stream.Write(' ');
 4375                stream.Write(value.ToString("F6", CultureInfo.InvariantCulture));
 376            }
 377
 4378            stream.WriteLine();
 379        }
 380
 4381        if (element.ParametersV.Count != 0)
 382        {
 4383            writeEnd = true;
 4384            stream.Write("parm v");
 385
 4386            foreach (float value in element.ParametersV)
 387            {
 4388                stream.Write(' ');
 4389                stream.Write(value.ToString("F6", CultureInfo.InvariantCulture));
 390            }
 391
 4392            stream.WriteLine();
 393        }
 394
 4395        if (element.OuterTrimmingCurves.Count != 0)
 396        {
 4397            writeEnd = true;
 4398            stream.Write("trim");
 399
 4400            foreach (ObjCurveIndex index in element.OuterTrimmingCurves)
 401            {
 4402                stream.Write(' ');
 4403                stream.Write(index);
 404            }
 405
 4406            stream.WriteLine();
 407        }
 408
 4409        if (element.InnerTrimmingCurves.Count != 0)
 410        {
 4411            writeEnd = true;
 4412            stream.Write("hole");
 413
 4414            foreach (ObjCurveIndex index in element.InnerTrimmingCurves)
 415            {
 4416                stream.Write(' ');
 4417                stream.Write(index);
 418            }
 419
 4420            stream.WriteLine();
 421        }
 422
 4423        if (element.SequenceCurves.Count != 0)
 424        {
 4425            writeEnd = true;
 4426            stream.Write("scrv");
 427
 4428            foreach (ObjCurveIndex index in element.SequenceCurves)
 429            {
 4430                stream.Write(' ');
 4431                stream.Write(index);
 432            }
 433
 4434            stream.WriteLine();
 435        }
 436
 4437        if (element.SpecialPoints.Count != 0)
 438        {
 4439            writeEnd = true;
 4440            stream.Write("sp");
 441
 4442            foreach (int point in element.SpecialPoints)
 443            {
 4444                stream.Write(' ');
 4445                stream.Write(point);
 446            }
 447
 4448            stream.WriteLine();
 449        }
 450
 4451        if (writeEnd)
 452        {
 4453            stream.WriteLine("end");
 454        }
 4455    }
 456}
Generated by: ReportGenerator 5.5.0.0
12/1/2025 - 2:57:23 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)