Merge pull request #26 from zrckr/gltf-exporter

Implement binary GLTF conversion from XNB and vice versa

Author: Krzyhau

Core/Conversion/FormatConversion.cs

@@ -18,7 +18,7 @@ public static class FormatConversion
         /// convert it and store in a <see cref="FileBundle"/>.
         /// </summary>
         /// <param name="data">A reference to object to convert</param>
-        /// <param name="configuration">A configuration dictionary to alter converter behaviour</param>
+        /// <param name="settings">A configuration to alter converter behaviour</param>
         /// <returns>
         /// A <see cref="FileBundle"/> containing file or files converted from given object.
         /// </returns>
@@ -28,7 +28,7 @@ public static class FormatConversion
         /// <exception cref="FormatConversionException">
         /// Thrown when a type of given object is not supported by Repacker
         /// </exception>
-        public static FileBundle Convert(object? data, IDictionary<string, object>? configuration = null)
+        public static FileBundle Convert(object? data, FormatConverterSettings? settings = null)
         {
             if(data == null)
             {
@@ -42,14 +42,7 @@ public static FileBundle Convert(object? data, IDictionary<string, object>? conf
                 throw new FormatConversionException($"Type {data.GetType()} is not supported for conversion.");
             }
 
-            if (configuration != null)
-            {
-                foreach (var pair in configuration)
-                {
-                    converter.Configuration.Add(pair);
-                }
-            }
-
+            converter.Settings = settings ?? new FormatConverterSettings();
             return converter.Convert(data);
         }
 
@@ -58,14 +51,14 @@ public static FileBundle Convert(object? data, IDictionary<string, object>? conf
         /// then attempts to deconvert it back to an object with a type assigned to this converter.
         /// </summary>
         /// <param name="bundle">A <see cref="FileBundle"/> containing files to convert.</param>
-        /// <param name="configuration">A configuration dictionary to alter converter behaviour</param>
+        /// <param name="settings">A configuration to alter converter behaviour</param>
         /// <returns>
         /// An object deconverted from files contained in given <see cref="FileBundle"/>.
         /// </returns>
         /// <exception cref="FormatConversionException">
         /// Thrown when main extension of given <see cref="FileBundle"/> is not supported by Repacker
         /// </exception>
-        public static object? Deconvert(FileBundle bundle, IDictionary<string, object>? configuration = null)
+        public static object? Deconvert(FileBundle bundle, FormatConverterSettings? settings = null)
         {
             var converter = FormatConverters.FindForFileBundle(bundle);
 
@@ -74,14 +67,7 @@ public static FileBundle Convert(object? data, IDictionary<string, object>? conf
                 throw new FormatConversionException($"File bundle type {bundle.MainExtension} is not supported for conversion.");
             }
 
-            if (configuration != null)
-            {
-                foreach (var pair in configuration)
-                {
-                    converter.Configuration.Add(pair);
-                }
-            }
-
+            converter.Settings = settings ?? new FormatConverterSettings();
             return converter.Deconvert(bundle);
         }
     }

Core/Conversion/FormatConverter.cs

@@ -17,7 +17,7 @@ public abstract class FormatConverter
         public abstract FileBundle Convert(object? data);
         public abstract object? Deconvert(FileBundle bundle);
 
-        public IDictionary<string, object> Configuration { get; } = new Dictionary<string, object>();
+        public FormatConverterSettings Settings { get; set; }
 
         public FileBundle Convert<T>(T data)
         {

Core/Conversion/FormatConverterSettings.cs

@@ -0,0 +1,25 @@
+using FEZRepacker.Core.Definitions.Game.ArtObject;
+using FEZRepacker.Core.Definitions.Game.TrileSet;
+
+namespace FEZRepacker.Core.Conversion
+{
+    /// <summary>
+    /// Contains data for changing the behavior of the converter
+    /// </summary>
+    public struct FormatConverterSettings()
+    {
+        /// <summary>
+        /// By default, the <see href="https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html">glTF</see>
+        /// all-in-one format is used for transmitting and editing <see cref="ArtObject"/> properties.
+        /// If the flag is true, the converter will use a legacy bundle with separate files.
+        /// </summary>
+        public bool UseLegacyArtObjectBundle = false;
+
+        /// <summary>
+        /// By default, the <see href="https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html">glTF</see>
+        /// all-in-one format is used for transmitting and editing <see cref="TrileSet"/> properties.
+        /// If the flag is true, the converter will use a legacy bundle with separate files.
+        /// </summary>
+        public bool UseLegacyTrileSetBundle = false;
+    }
+}

Core/Conversion/Formats/ArtObjectConverter.cs

@@ -1,11 +1,16 @@
 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
@@ -16,6 +21,11 @@ internal class ArtObjectConverter : FormatConverter<ArtObject>
 
         public override FileBundle ConvertTyped(ArtObject data)
         {
+            if (!Settings.UseLegacyArtObjectBundle)
+            {
+                return FileBundle.Single(GetTransmissionFormatStream(data), FileFormat, ".glb");
+            }
+            
             var bundle = ConfiguredJsonSerializer.SerializeToFileBundle(FileFormat, data);
 
             bundle.AddFile(GetTextureStream(data, TexturesUtil.CubemapPart.Albedo), ".png");
@@ -27,13 +37,20 @@ public override FileBundle ConvertTyped(ArtObject data)
 
         public override ArtObject DeconvertTyped(FileBundle bundle)
         {
-            var artObject = ConfiguredJsonSerializer.DeserializeFromFileBundle<ArtObject>(bundle);
-
-            AppendGeometryStream(ref artObject, bundle.RequireData(".obj"));
-            LoadCubemap(ref artObject, bundle.GetData(".png"), bundle.GetData(".apng"));
+            try
+            {
+                return LoadFromTransmissionFormat(bundle.RequireData(".glb"));
+            }
+            catch (FileNotFoundException)
+            {
+                Console.WriteLine("  The glTF bundle was not found! Using legacy art object bundle format...");
+                var artObject = ConfiguredJsonSerializer.DeserializeFromFileBundle<ArtObject>(bundle);
 
+                AppendGeometryStream(ref artObject, bundle.RequireData(".obj"));
+                LoadCubemap(ref artObject, bundle.GetData(".png"), bundle.GetData(".apng"));
 
-            return artObject;
+                return artObject;
+            }
         }
 
         private static Stream GetTextureStream(ArtObject data, TexturesUtil.CubemapPart part)
@@ -47,20 +64,48 @@ private static Stream GetModelStream(ArtObject data)
             return new MemoryStream(Encoding.UTF8.GetBytes(data.Geometry.ToWavefrontObj()));
         }
 
+        private static Stream GetTransmissionFormatStream(ArtObject data)
+        {
+            using var albedo =
+                TexturesUtil.ExtractCubemapPartFromTexture(data.Cubemap, TexturesUtil.CubemapPart.Albedo);
+            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);
+            return GltfUtil.ToGltfModel(entry, albedo, emission).SaveAsGlb();
+        }
+
+        private static ArtObject LoadFromTransmissionFormat(Stream modelStream)
+        {
+            var modelRoot = ModelRoot.ReadGLB(modelStream);
+            var entries = GltfUtil.FromGltfModel<Matrix>(modelRoot);
+            
+            if (entries.Count < 1)
+                return new ArtObject();
+
+            var entry = entries.First();
+            var artObject = ConfiguredJsonSerializer.DeserializeFromNode<ArtObject>(entry.Extras);
+            artObject.Geometry = entry.Geometry;
+            TrixelArtUtil.RecalculateCubemapTexCoords(artObject.Geometry, artObject.Size);
+            
+            (Stream? albedo, Stream? emission) = GltfUtil.ExtractCubemapStreams(modelRoot);
+            LoadCubemap(ref artObject, albedo, emission);
+
+            return artObject;
+        }
+
         private static void AppendGeometryStream(ref ArtObject data, Stream geometryStream)
         {
             var geometries = TrixelArtUtil.LoadGeometry<Matrix>(geometryStream);
-            if (geometries.Count() > 0)
-            {
-                data.Geometry = geometries.First().Value;
-                TrixelArtUtil.RecalculateCubemapTexCoords(data.Geometry, data.Size);
-            }
+            if (geometries.Count < 1) return;
+            data.Geometry = geometries.First().Value;
+            TrixelArtUtil.RecalculateCubemapTexCoords(data.Geometry, data.Size);
         }
 
-        private static void LoadCubemap(ref ArtObject data, Stream albedoStream, Stream emissionStream)
+        private static void LoadCubemap(ref ArtObject data, Stream? albedoStream, Stream? emissionStream)
         {
             using var image = TexturesUtil.ConstructCubemap(albedoStream, emissionStream);
             data.Cubemap = TexturesUtil.ImageToTexture2D(image);
         }
     }
-}
+}

Core/Conversion/Formats/TrileSetConverter.cs

@@ -1,4 +1,5 @@
 using System.Text;
+using System.Text.Json.Nodes;
 
 using FEZRepacker.Core.Definitions.Game.ArtObject;
 using FEZRepacker.Core.Definitions.Game.Graphics;
@@ -8,6 +9,8 @@
 using FEZRepacker.Core.Helpers;
 using FEZRepacker.Core.Helpers.Json;
 
+using SharpGLTF.Schema2;
+
 using SixLabors.ImageSharp.Formats.Png;
 
 namespace FEZRepacker.Core.Conversion.Formats
@@ -16,8 +19,15 @@ internal class TrileSetConverter : FormatConverter<TrileSet>
     {
         public override string FileFormat => ".fezts";
 
+        private const string TrileIdKey = "TrileId";
+
         public override FileBundle ConvertTyped(TrileSet data)
         {
+            if (!Settings.UseLegacyTrileSetBundle)
+            {
+                return FileBundle.Single(GetTransmissionFormatStream(data), FileFormat, ".glb");
+            }
+            
             var bundle = ConfiguredJsonSerializer.SerializeToFileBundle(FileFormat, data);
 
             bundle.AddFile(GetTextureStream(data, TexturesUtil.CubemapPart.Albedo), ".png");
@@ -29,12 +39,20 @@ public override FileBundle ConvertTyped(TrileSet data)
 
         public override TrileSet DeconvertTyped(FileBundle bundle)
         {
-            var trileSet = ConfiguredJsonSerializer.DeserializeFromFileBundle<TrileSet>(bundle);
-
-            AppendGeometryStream(ref trileSet, bundle.RequireData(".obj"));
-            LoadCubemap(ref trileSet, bundle.GetData(".png"), bundle.GetData(".apng"));
-
-            return trileSet;
+            try
+            {
+                return LoadFromTransmissionFormat(bundle.RequireData(".glb"));
+            }
+            catch (FileNotFoundException)
+            {
+                Console.WriteLine("  The glTF bundle was not found! Using legacy trile set bundle format...");
+                var trileSet = ConfiguredJsonSerializer.DeserializeFromFileBundle<TrileSet>(bundle);
+            
+                AppendGeometryStream(ref trileSet, bundle.RequireData(".obj"));
+                LoadCubemap(ref trileSet, bundle.GetData(".png"), bundle.GetData(".apng"));
+            
+                return trileSet;
+            }
         }
 
         private static Stream GetTextureStream(TrileSet data, TexturesUtil.CubemapPart part)
@@ -51,10 +69,51 @@ private static Stream GetModelStream(TrileSet data)
             {
                 geometryDict[trileRecord.Key.ToString()] = trileRecord.Value.Geometry;
             }
+
             var objString = WavefrontObjUtil.ToWavefrontObj(geometryDict);
             return new MemoryStream(Encoding.UTF8.GetBytes(objString));
         }
 
+        private static Stream GetTransmissionFormatStream(TrileSet data)
+        {
+            var entries = new List<GltfEntry<Vector4>>();
+            foreach (var trileRecord in data.Triles)
+            {
+                var extras = ConfiguredJsonSerializer.SerializeToNode(trileRecord.Value);
+                extras[TrileIdKey] = trileRecord.Key;
+                entries.Add(new GltfEntry<Vector4>(trileRecord.Value.Name, trileRecord.Value.Geometry, extras));
+            }
+
+            using var albedo =
+                TexturesUtil.ExtractCubemapPartFromTexture(data.TextureAtlas, TexturesUtil.CubemapPart.Albedo);
+            using var emission =
+                TexturesUtil.ExtractCubemapPartFromTexture(data.TextureAtlas, TexturesUtil.CubemapPart.Emission);
+
+            return GltfUtil.ToGltfModel(data.Name, entries, albedo, emission).SaveAsGlb();
+        }
+        
+        private static TrileSet LoadFromTransmissionFormat(Stream modelStream)
+        {
+            var modelRoot = ModelRoot.ReadGLB(modelStream);
+            var trileSet = new TrileSet { Name = modelRoot.DefaultScene.Name };
+
+            var entries = GltfUtil.FromGltfModel<Vector4>(modelRoot);
+            foreach (var entry in entries)
+            {
+                var id = entry.Extras[TrileIdKey]!.GetValue<int>();
+                if (!trileSet.Triles.ContainsKey(id))
+                {
+                    trileSet.Triles[id] = ConfiguredJsonSerializer.DeserializeFromNode<Trile>(entry.Extras);
+                }
+
+                trileSet.Triles[id].Geometry = entry.Geometry;
+            }
+
+            (Stream? albedo, Stream? emission) = GltfUtil.ExtractCubemapStreams(modelRoot);
+            LoadCubemap(ref trileSet, albedo, emission);
+            
+            return trileSet;
+        }
 
         private static void AppendGeometryStream(ref TrileSet data, Stream geometryStream)
         {
@@ -67,14 +126,15 @@ private static void AppendGeometryStream(ref TrileSet data, Stream geometryStrea
                 {
                     data.Triles[id] = new Trile();
                 }
+
                 data.Triles[id].Geometry = objRecord.Value;
             }
         }
 
-        private static void LoadCubemap(ref TrileSet data, Stream albedoStream, Stream emissionStream)
+        private static void LoadCubemap(ref TrileSet data, Stream? albedoStream, Stream? emissionStream)
         {
             using var image = TexturesUtil.ConstructCubemap(albedoStream, emissionStream);
             data.TextureAtlas = TexturesUtil.ImageToTexture2D(image);
         }
     }
-}
+}

Core/Definitions/Game/XNA/Quaternion.cs

@@ -37,6 +37,9 @@ public bool Equals(Quaternion other) =>
             this.X == other.X && this.Y == other.Y && this.Z == other.Z && this.W == other.W;
         public static bool operator ==(Quaternion left, Quaternion right) => left.Equals(right);
         public static bool operator !=(Quaternion left, Quaternion right) => !left.Equals(right);
+        
+        public System.Numerics.Quaternion ToNumeric() => new(this.X, this.Y, this.Z, this.W);
+        public static Quaternion FromNumeric(System.Numerics.Quaternion numeric) => new(numeric.X, numeric.Y, numeric.Z, numeric.W);
 
         public override int GetHashCode()
         {

Core/Definitions/Game/XNA/Vector2.cs

@@ -22,6 +22,9 @@ public bool Equals(Vector2 other) =>
             this.X == other.X && this.Y == other.Y;
         public static bool operator ==(Vector2 left, Vector2 right) => left.Equals(right);
         public static bool operator !=(Vector2 left, Vector2 right) => !left.Equals(right);
+        
+        public System.Numerics.Vector2 ToNumeric() => new(this.X, this.Y);
+        public static Vector2 FromNumeric(System.Numerics.Vector2 numeric) => new(numeric.X, numeric.Y);
 
         public override int GetHashCode()
         {

Core/Definitions/Game/XNA/Vector3.cs

@@ -44,6 +44,9 @@ public bool Equals(Vector3 other) =>
         public static bool operator ==(Vector3 left, Vector3 right) => left.Equals(right);
         public static bool operator !=(Vector3 left, Vector3 right) => !left.Equals(right);
 
+        public System.Numerics.Vector3 ToNumeric() => new(this.X, this.Y, this.Z);
+        public static Vector3 FromNumeric(System.Numerics.Vector3 numeric) => new(numeric.X, numeric.Y, numeric.Z);
+
         public override int GetHashCode()
         {
             return this.X.GetHashCode() ^ this.Y.GetHashCode() << 2 ^ this.Z.GetHashCode() >> 2;