handle trixel art winding issue

meshes in fez are clockwise-front-facing, which needs converting

Author: Krzyhau

Core/Conversion/Formats/ArtObjectConverter.cs

@@ -1,16 +1,12 @@
 using System.Text;
-using System.Text.Json.Nodes;
 
 using FEZRepacker.Core.Definitions.Game.ArtObject;
-using FEZRepacker.Core.Definitions.Game.Graphics;
 using FEZRepacker.Core.Definitions.Game.XNA;
 using FEZRepacker.Core.FileSystem;
 using FEZRepacker.Core.Helpers;
 using FEZRepacker.Core.Helpers.Json;
 
 using SharpGLTF.Schema2;
-using SharpGLTF.Validation;
-
 using SixLabors.ImageSharp.Formats.Png;
 
 namespace FEZRepacker.Core.Conversion.Formats
@@ -61,7 +57,8 @@ private static Stream GetTextureStream(ArtObject data, TexturesUtil.CubemapPart
 
         private static Stream GetModelStream(ArtObject data)
         {
-            return new MemoryStream(Encoding.UTF8.GetBytes(data.Geometry.ToWavefrontObj()));
+            var geometry = data.Geometry.WithReversedWindingIndices();
+            return new MemoryStream(Encoding.UTF8.GetBytes(geometry.ToWavefrontObj()));
         }
 
         private static Stream GetTransmissionFormatStream(ArtObject data)
@@ -71,7 +68,7 @@ private static Stream GetTransmissionFormatStream(ArtObject data)
             using var emission =
                 TexturesUtil.ExtractCubemapPartFromTexture(data.Cubemap, TexturesUtil.CubemapPart.Emission);
             var extras = ConfiguredJsonSerializer.SerializeToNode(data);
-            var entry = new GltfEntry<Matrix>(data.Name, data.Geometry, extras);
+            var entry = new GltfEntry<Matrix>(data.Name, data.Geometry.WithReversedWindingIndices(), extras);
             return GltfUtil.ToGltfModel(entry, albedo, emission).SaveAsGlb();
         }
 
@@ -85,8 +82,8 @@ private static ArtObject LoadFromTransmissionFormat(Stream modelStream)
 
             var entry = entries.First();
             var artObject = ConfiguredJsonSerializer.DeserializeFromNode<ArtObject>(entry.Extras) ?? new ArtObject();
-            artObject.Geometry = entry.Geometry;
-            TrixelArtUtil.RecalculateCubemapTexCoords(artObject.Geometry, artObject.Size);
+            artObject.Geometry = entry.Geometry.WithReversedWindingIndices();
+            FezGeometryUtil.RecalculateCubemapTexCoords(artObject.Geometry, artObject.Size);
 
             (Stream? albedo, Stream? emission) = GltfUtil.ExtractCubemapStreams(modelRoot);
             LoadCubemap(ref artObject, albedo, emission);
@@ -96,10 +93,10 @@ private static ArtObject LoadFromTransmissionFormat(Stream modelStream)
 
         private static void AppendGeometryStream(ref ArtObject data, Stream geometryStream)
         {
-            var geometries = TrixelArtUtil.LoadGeometry<Matrix>(geometryStream);
+            var geometries = WavefrontObjUtil.FromWavefrontObjStream<Matrix>(geometryStream);
             if (geometries.Count < 1) return;
-            data.Geometry = geometries.First().Value;
-            TrixelArtUtil.RecalculateCubemapTexCoords(data.Geometry, data.Size);
+            data.Geometry = geometries.First().Value.WithReversedWindingIndices();
+            FezGeometryUtil.RecalculateCubemapTexCoords(data.Geometry, data.Size);
         }
 
         private static void LoadCubemap(ref ArtObject data, Stream? albedoStream, Stream? emissionStream)

Core/Conversion/Formats/TrileSetConverter.cs

@@ -67,7 +67,7 @@ private static Stream GetModelStream(TrileSet data)
 
             foreach (var trileRecord in data.Triles)
             {
-                geometryDict[trileRecord.Key.ToString()] = trileRecord.Value.Geometry;
+                geometryDict[trileRecord.Key.ToString()] = trileRecord.Value.Geometry.WithReversedWindingIndices();
             }
 
             var objString = WavefrontObjUtil.ToWavefrontObj(geometryDict);
@@ -81,7 +81,8 @@ private static Stream GetTransmissionFormatStream(TrileSet data)
             {
                 var extras = ConfiguredJsonSerializer.SerializeToNode(trileRecord.Value) ?? new JsonObject();
                 extras[TrileIdKey] = trileRecord.Key;
-                entries.Add(new GltfEntry<Vector4>(trileRecord.Value.Name, trileRecord.Value.Geometry, extras));
+                var geometry = trileRecord.Value.Geometry.WithReversedWindingIndices();
+                entries.Add(new GltfEntry<Vector4>(trileRecord.Value.Name, geometry, extras));
             }
 
             using var albedo =
@@ -111,7 +112,7 @@ private static TrileSet LoadFromTransmissionFormat(Stream modelStream)
                     trileSet.Triles[id] = ConfiguredJsonSerializer.DeserializeFromNode<Trile>(entry.Extras) ?? new Trile();
                 }
 
-                trileSet.Triles[id].Geometry = entry.Geometry;
+                trileSet.Triles[id].Geometry = entry.Geometry.WithReversedWindingIndices();
             }
 
             (Stream? albedo, Stream? emission) = GltfUtil.ExtractCubemapStreams(modelRoot);
@@ -122,7 +123,7 @@ private static TrileSet LoadFromTransmissionFormat(Stream modelStream)
 
         private static void AppendGeometryStream(ref TrileSet data, Stream geometryStream)
         {
-            var geometries = TrixelArtUtil.LoadGeometry<Vector4>(geometryStream);
+            var geometries = WavefrontObjUtil.FromWavefrontObjStream<Vector4>(geometryStream);
             foreach (var objRecord in geometries)
             {
                 var id = int.Parse(objRecord.Key);
@@ -132,7 +133,7 @@ private static void AppendGeometryStream(ref TrileSet data, Stream geometryStrea
                     data.Triles[id] = new Trile();
                 }
 
-                data.Triles[id].Geometry = objRecord.Value;
+                data.Triles[id].Geometry = objRecord.Value.WithReversedWindingIndices();
             }
         }
 

Core/Helpers/TrixelArtUtil.cs Core/Helpers/FezGeometryUtil.csCore/Helpers/TrixelArtUtil.cs renamed to Core/Helpers/FezGeometryUtil.cs

@@ -1,27 +1,15 @@
-using System.Text;
-
-using FEZRepacker.Core.Definitions.Game.ArtObject;
+using FEZRepacker.Core.Definitions.Game.ArtObject;
 using FEZRepacker.Core.Definitions.Game.Graphics;
 using FEZRepacker.Core.Definitions.Game.XNA;
 
 namespace FEZRepacker.Core.Helpers
 {
-    internal static class TrixelArtUtil
+    internal static class FezGeometryUtil
     {
-        public static Dictionary<string, IndexedPrimitives<VertexInstance, VertexType>> LoadGeometry<VertexType>(Stream geometryStream)
-        {
-            using var geometryReader = new BinaryReader(geometryStream, Encoding.UTF8, true);
-            string geometryString = new string(geometryReader.ReadChars((int)geometryStream.Length));
-            return WavefrontObjUtil.FromWavefrontObj<VertexType>(geometryString);
-        }
-
-        /// <summary>
         /// Recalculates texture coordinates to match what game does with them during loading process.
-        /// </summary>
-        /// <typeparam name="VertexType">Type of modified geometry</typeparam>
-        /// <param name="geometry">Geometry to modify</param>
-        /// <param name="geometryBounds">Bounds of the geometry to calculate texture coordinates with.</param>
-        public static void RecalculateCubemapTexCoords<VertexType>(IndexedPrimitives<VertexInstance, VertexType> geometry, Vector3 geometryBounds) {
+        public static void RecalculateCubemapTexCoords<VertexType>(
+            IndexedPrimitives<VertexInstance, VertexType> geometry, Vector3 geometryBounds
+        ) {
             foreach (var vertex in geometry.Vertices)
             {
                 (int textureOffset, Vector3 xAxis, Vector3 yAxis) = vertex.NormalByte switch
@@ -42,5 +30,31 @@ public static void RecalculateCubemapTexCoords<VertexType>(IndexedPrimitives<Ver
                 );
             }
         }
+        
+        // FEZ meshes are counter-clockwise culled, which is the opposite of what most 3D software uses for front faces.
+        public static IndexedPrimitives<VertexInstance, VertexType> WithReversedWindingIndices<VertexType>(
+            this IndexedPrimitives<VertexInstance, VertexType> geometry
+        )
+        {
+            var newGeometry = new IndexedPrimitives<VertexInstance, VertexType>()
+            {
+                PrimitiveType = geometry.PrimitiveType,
+                Vertices = geometry.Vertices,
+                Indices = new ushort[geometry.Indices.Length]
+            };
+            
+            for (int i = 0; i < geometry.Indices.Length; i++)
+            {
+                var index = geometry.PrimitiveType switch
+                {
+                    PrimitiveType.TriangleList => i + (((i + 1) % 3) - 1),
+                    PrimitiveType.TriangleStrip => geometry.Indices.Length - (i + 1),
+                    _ => i
+                };
+                newGeometry.Indices[i] = geometry.Indices[index];
+            }
+            
+            return newGeometry;
+        }
     }
 }

Core/Helpers/GltfUtil.cs

@@ -172,7 +172,6 @@ private static Material CreateMaterial(
             ImageBuilder emissionImage = emission.SaveAsMemoryStream(new PngEncoder()).ToArray();
 
             var materialBuilder = new MaterialBuilder()
-                .WithDoubleSide(true)
                 .WithMetallicRoughnessShader();
 
             materialBuilder

Core/Helpers/WavefrontObjUtil.cs

@@ -74,17 +74,23 @@ public static string ToWavefrontObj<T>(this IndexedPrimitives<VertexInstance,T>
             {
                 for (int i = 2; i < indices.Count() - indices.Count() % 3; i += (isList ? 3 : 1))
                 {
-                    // revert orders of indices
-                    int i3 = indices[i - 2] + iOffset;
+                    int i1 = indices[i - 2] + iOffset;
                     int i2 = indices[i - 1] + iOffset;
-                    int i1 = indices[i] + iOffset;
+                    int i3 = indices[i] + iOffset;
 
                     objBuilder.AppendLine($"f {i1}/{i1}/{i1} {i2}/{i2}/{i2} {i3}/{i3}/{i3}");
                 }
             }
 
             return objBuilder.ToString();
         }
+        
+        public static Dictionary<string, IndexedPrimitives<VertexInstance, T>> FromWavefrontObjStream<T>(Stream objStream)
+        {
+            using var geometryReader = new BinaryReader(objStream, Encoding.UTF8, true);
+            string geometryString = new string(geometryReader.ReadChars((int)objStream.Length));
+            return FromWavefrontObj<T>(geometryString);
+        }
 
         public static Dictionary<string, IndexedPrimitives<VertexInstance, T>> FromWavefrontObj<T>(string obj)
         {
@@ -148,10 +154,9 @@ public static Dictionary<string, IndexedPrimitives<VertexInstance, T>> FromWavef
 
                 else if(tokens[0] == "f" && tokens.Length >= 4)
                 {
-                    // revert orders of indices
-                    indicesGroup[indicesGroup.Count - 1].Add(tokens[3]);
-                    indicesGroup[indicesGroup.Count - 1].Add(tokens[2]);
                     indicesGroup[indicesGroup.Count - 1].Add(tokens[1]);
+                    indicesGroup[indicesGroup.Count - 1].Add(tokens[2]);
+                    indicesGroup[indicesGroup.Count - 1].Add(tokens[3]);
                 }
             }