Support class UFont, UMultiFont for standard (UE1, UE1, UE3).

EliotVU · Oct 14, 2022 · aa5ca86 · aa5ca86
1 parent 94e0292
commit aa5ca86
Show file tree

Hide file tree

Showing 5 changed files with 184 additions and 28 deletions.
diff --git a/src/Branch/BuildAttribute.cs b/src/Branch/BuildAttribute.cs
@@ -15,4 +15,25 @@ public BuildAttribute(UnrealPackage.GameBuild.BuildName build)
             Build = build;
         }
     }
-}
+
+    /// <summary>
+    /// Not yet usable.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property)]
+    public class BuildGenerationAttribute : Attribute
+    {
+        public readonly BuildGeneration Generation;
+        public readonly int EngineVersion = -1;
+
+        public BuildGenerationAttribute(BuildGeneration generation)
+        {
+            Generation = generation;
+        }
+
+        public BuildGenerationAttribute(BuildGeneration generation, int engineVersion)
+        {
+            Generation = generation;
+            EngineVersion = engineVersion;
+        }
+    }
+}
diff --git a/src/Branch/PackageObjectLegacyVersion.cs b/src/Branch/PackageObjectLegacyVersion.cs
@@ -10,6 +10,8 @@ public enum PackageObjectLegacyVersion
         ReturnExpressionAddedToReturnToken = 62,
 
         SphereExtendsPlane = 62,
+
+        CharRemapAddedToUFont = 69,
 
         /// <summary>
         /// FIXME: Unknown version.
@@ -21,6 +23,10 @@ public enum PackageObjectLegacyVersion
         /// </summary>
         PrimitiveCastTokenAdded = 95,
 
+
+        KerningAddedToUFont = 119,
+        FontPagesDisplaced = 122,
+
         UE3 = 184,
         RangeConstTokenDeprecated = UE3,
 
@@ -30,6 +36,10 @@ public enum PackageObjectLegacyVersion
         /// FIXME: Unknown version.
         /// </summary>
         IsLocalAddedToDelegateFunctionToken = 181,
+
+        VerticalOffsetAddedToUFont = 506,
+        CleanupFonts = 511,
+
         ProbeMaskReducedAndIgnoreMaskRemoved = 692,
         ForceScriptOrderAddedToUClass = 749,
         SuperReferenceMovedToUStruct = 756,

diff --git a/src/Eliot.UELib.csproj b/src/Eliot.UELib.csproj
@@ -180,7 +180,9 @@
     <Compile Include="Core\Types\UCoords.cs" />
     <Compile Include="Core\Types\UPlane.cs" />
     <Compile Include="Core\Types\UScale.cs" />
-    <Compile Include="Core\Types\USphere.cs" />    <Compile Include="Core\Types\UColor.cs" />
+    <Compile Include="Core\Types\USphere.cs" />
+    <Compile Include="Engine\Classes\UMultiFont.cs" />
+    <Compile Include="Core\Types\UColor.cs" />
     <Compile Include="Core\Types\UMap.cs" />
     <Compile Include="Core\Types\UVector.cs" />
     <Compile Include="Core\UStateFrame.cs" />

diff --git a/src/Engine/Classes/UFont.cs b/src/Engine/Classes/UFont.cs
@@ -1,4 +1,4 @@
-using System;
+using UELib.Branch;
 using UELib.Core;
 
 namespace UELib.Engine
@@ -9,52 +9,150 @@ namespace UELib.Engine
     [UnrealRegisterClass]
     public class UFont : UObject, IUnrealViewable
     {
+        public UArray<FontCharacter> Characters;
+        public UArray<UObject> Textures;
+        public int Kerning;
+        public UMap<ushort, ushort> CharRemap;
+        public bool IsRemapped;
+
         public UFont()
         {
             ShouldDeserializeOnDemand = true;
         }
-        
-        private struct FontCharacter : IUnrealSerializableClass
+
+        protected override void Deserialize()
         {
-            private int _StartU;
-            private int _StartV;
-            private int _USize;
-            private int _VSize;
-            byte _TextureIndex;
+            base.Deserialize();
 
-            public void Serialize(IUnrealStream stream)
+            if (_Buffer.Version < (uint)PackageObjectLegacyVersion.FontPagesDisplaced)
+            {
+                _Buffer.Read(out UArray<FontPage> pages);
+                Record(nameof(pages), pages);
+
+                _Buffer.Read(out int charactersPerPage);
+                Record(nameof(charactersPerPage), charactersPerPage);
+
+                Characters = new UArray<FontCharacter>();
+                Textures = new UArray<UObject>();
+                for (var i = 0; i < pages.Count; i++)
+                {
+                    Textures.Add(pages[i].Texture);
+                    foreach (var c in pages[i].Characters)
+                    {
+                        var character = c;
+                        character.TextureIndex = (byte)i;
+                        Characters.Add(character);
+                    }
+                }
+
+                if (pages.Count == 0 && charactersPerPage == 0)
+                {
+                    _Buffer.Read(out string fontName);
+                    Record(nameof(fontName), fontName);
+
+                    _Buffer.Read(out int fontHeight);
+                    Record(nameof(fontHeight), fontHeight);
+                }
+            }
+            else if (_Buffer.Version < (uint)PackageObjectLegacyVersion.CleanupFonts)
             {
-                throw new NotImplementedException();
+                _Buffer.Read(out Characters);
+                Record(nameof(Characters), Characters);
+
+                _Buffer.Read(out Textures);
+                Record(nameof(Textures), Textures);
+
+                if (_Buffer.Version >= (uint)PackageObjectLegacyVersion.KerningAddedToUFont)
+                {
+                    _Buffer.Read(out Kerning);
+                    Record(nameof(Kerning), Kerning);
+                }
             }
 
-            public void Deserialize(IUnrealStream stream)
+            if (_Buffer.Version >= (uint)PackageObjectLegacyVersion.CharRemapAddedToUFont)
             {
-                _StartU = stream.ReadInt32();
-                _StartV = stream.ReadInt32();
+                _Buffer.Read(out CharRemap);
+                Record(nameof(CharRemap), CharRemap);
 
-                _USize = stream.ReadInt32();
-                _VSize = stream.ReadInt32();
+                if (_Buffer.Version >= (uint)PackageObjectLegacyVersion.CleanupFonts)
+                {
+                    return;
+                }
 
-                _TextureIndex = stream.ReadByte();
+                _Buffer.Read(out IsRemapped);
+                Record(nameof(IsRemapped), IsRemapped);
+
+                //if (_Buffer.Package.Build == UnrealPackage.GameBuild.BuildName.Unreal2XMP &&
+                //    _Buffer.LicenseeVersion > 0)
+                //{
+                //    _Buffer.Read(out int xPad);
+                //    _Buffer.Read(out int yPad);
+                //}
             }
-        };
+        }
 
-        private UArray<FontCharacter> _Characters;
+        public struct FontPage : IUnrealSerializableClass
+        {
+            public UTexture Texture;
+            public UArray<FontCharacter> Characters;
 
-        protected override void Deserialize()
+            public void Deserialize(IUnrealStream stream)
+            {
+                stream.Read(out Texture);
+                stream.Read(out Characters);
+            }
+
+            public void Serialize(IUnrealStream stream)
+            {
+                stream.Write(Texture);
+                stream.Write(ref Characters);
+            }
+        }
+
+        public struct FontCharacter : IUnrealSerializableClass
         {
-            base.Deserialize();
+            public int StartU;
+            public int StartV;
+            public int USize;
+            public int VSize;
+            public byte TextureIndex;
+            public int VerticalOffset;
+
+            public void Deserialize(IUnrealStream stream)
+            {
+                stream.Read(out StartU);
+                stream.Read(out StartV);
+                stream.Read(out USize);
+                stream.Read(out VSize);
 
-			_Buffer.ReadArray(out _Characters);
+                if (stream.Version >= (uint)PackageObjectLegacyVersion.FontPagesDisplaced)
+                {
+                    stream.Read(out TextureIndex);
+                }
 
-            // Textures
+                if (stream.Version >= (uint)PackageObjectLegacyVersion.VerticalOffsetAddedToUFont)
+                {
+                    stream.Read(out VerticalOffset);
+                }
+            }
 
-            // Kerning
-            _Buffer.ReadInt32();
+            public void Serialize(IUnrealStream stream)
+            {
+                stream.Write(StartU);
+                stream.Write(StartV);
+                stream.Write(USize);
+                stream.Write(VSize);
 
-            // Remap
+                if (stream.Version >= (uint)PackageObjectLegacyVersion.FontPagesDisplaced)
+                {
+                    stream.Write(TextureIndex);
+                }
 
-            _Buffer.UR.ReadBoolean();
+                if (stream.Version >= (uint)PackageObjectLegacyVersion.VerticalOffsetAddedToUFont)
+                {
+                    stream.Write(VerticalOffset);
+                }
+            }
         }
     }
 }
diff --git a/src/Engine/Classes/UMultiFont.cs b/src/Engine/Classes/UMultiFont.cs
@@ -0,0 +1,25 @@
+using UELib.Branch;
+using UELib.Core;
+
+namespace UELib.Engine
+{
+    /// <summary>
+    /// Represents the UMultiFont:Engine.MultiFont
+    /// </summary>
+    [UnrealRegisterClass]
+    [BuildGeneration(BuildGeneration.UE3)]
+    public class UMultiFont : UFont
+    {
+        public UArray<float> ResolutionTestTable;
+
+        protected override void Deserialize()
+        {
+            base.Deserialize();
+
+            if (_Buffer.Version < (uint)PackageObjectLegacyVersion.CleanupFonts)
+            {
+                _Buffer.ReadArray(out ResolutionTestTable);
+            }
+        }
+    }
+}