Finalize TTF to VEC font builder

Nenkai · Nenkai · commit 75f187933481 · 2023-02-25T16:15:14.000+01:00
diff --git a/PDTools.Files.Fonts.NVecBuilder/PDTools.Files.Fonts.NVecBuilder.csproj b/PDTools.Files.Fonts.NVecBuilder/PDTools.Files.Fonts.NVecBuilder.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <Product>nvec_builder</Product>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <AssemblyName>nvec_builder</AssemblyName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PDTools.Files\PDTools.Files.csproj" />
+  </ItemGroup>
+
+  <Import Project="..\Typography\Typography.OpenFont\Typography.OpenFont.projitems" Label="Shared" />
+</Project>
diff --git a/PDTools.Files.Fonts.NVecBuilder/Program.cs b/PDTools.Files.Fonts.NVecBuilder/Program.cs
@@ -0,0 +1,46 @@
+﻿using PDTools.Files.Fonts;
+
+using System;
+using System.IO;
+
+namespace PDTools.Files.Fonts.NVecBuilder
+{
+    internal class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("NVecBuilder by Nenkai#9075");
+
+            if (args.Length != 2)
+            {
+                Console.WriteLine("This tool is intended for GT5/6 (older PS3 GTs uses older versions of vector fonts)");
+                Console.WriteLine("  Usage: nvec_builder.exe <input_ttf_file> <output_vec_file>");
+                return;
+            }
+
+            Console.WriteLine();
+
+            if (!File.Exists(args[0]))
+            {
+                Console.WriteLine("Input TTF file does not exist");
+                return;
+            }
+
+            args[1] = Path.GetFullPath(args[1]);
+            Directory.CreateDirectory(Path.GetDirectoryName(args[1]));
+
+            try
+            {
+                TrueTypeToNVecConverter.Convert(args[0], args[1]);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Failed to convert: {ex}");
+                return;
+            }
+
+            Console.WriteLine($"TTF -> NVEC -> {args[1]}");
+
+        }
+    }
+}
diff --git a/PDTools.Files.Fonts.NVecBuilder/TrueTypeToNVecConverter.cs b/PDTools.Files.Fonts.NVecBuilder/TrueTypeToNVecConverter.cs
@@ -10,17 +10,15 @@
 using TTFGlyph = Typography.OpenFont.Glyph;
 using NVecGlyph = PDTools.Files.Fonts.Glyph;
 
-namespace PDTools.Files.Fonts
+namespace PDTools.Files.Fonts.NVecBuilder
 {
     public class TrueTypeToNVecConverter
     {
-        /* Some notes:
-         * May not be the prettiest conversion code, Y is also swapped around
-         * "/ 2" is hardcoded for 2048 units per em fonts */
-
-        public static int Scale { get; set; } = 2;
         public static void Convert(string inputTtf, string outputVec)
         {
+            if (Path.GetExtension(inputTtf) == ".otf")
+                throw new NotSupportedException("otf (OpenType) is not supported (incompatible curves).");
+
             using var ttf = File.OpenRead(inputTtf);
             Typeface ttfFont = new OpenFontReader().Read(ttf);
 
@@ -30,22 +28,26 @@ public static void Convert(string inputTtf, string outputVec)
             ttfFont.CollectUnicode(unicodes);
             unicodes = unicodes.Distinct().ToList();
 
+            Console.WriteLine($"TTF: {unicodes.Count} unicode characters");
+            Console.WriteLine($"TTF: {ttfFont.UnitsPerEm} units per em");
+
+            int Scale = ttfFont.UnitsPerEm > 1024 ? ttfFont.UnitsPerEm / 1024 : 1;
+
             foreach (var codePoint in unicodes)
             {
                 if (codePoint == 0)
                     continue;
 
                 ushort glyphIndex = ttfFont.GetGlyphIndex((int)codePoint);
                 TTFGlyph ttfGlyph = ttfFont.GetGlyph(glyphIndex);
-
                 NVecGlyph vecGlyph = new NVecGlyph((char)codePoint);
-                vecGlyph.AdvanceWidth = (ushort)(ttfFont.GetAdvanceWidthFromGlyphIndex((ushort)glyphIndex) / Scale);
+
+                Console.WriteLine($"TTF: Processing '{(char)codePoint}' ({codePoint:X4}) with {ttfGlyph.GlyphPoints.Length} points");
 
                 int offset = ttfFont.Bounds.YMax - ttfGlyph.Bounds.YMax;
                 vecGlyph.HeightOffset = (ushort)(offset / Scale);
 
                 Span<ushort> endPoints = ttfGlyph.EndPoints.AsSpan();
-
                 GlyphPointF lastPoint = default;
 
                 if (ttfGlyph.GlyphPoints.Any())
@@ -64,7 +66,7 @@ public static void Convert(string inputTtf, string outputVec)
                                 var prev = ttfGlyph.GlyphPoints[i - 1];
                                 if (prev.onCurve)
                                 {
-                                    IGlyphShapeData shape = CompareAdd(prev, currentOutlineStartPoint);
+                                    IGlyphShapeData shape = CompareAdd(prev, currentOutlineStartPoint, Scale);
                                     vecGlyph.Points.Data.Add(shape);
                                 }
                             }
@@ -109,51 +111,52 @@ public static void Convert(string inputTtf, string outputVec)
                                     }
                                 }
                                 
-                                var curve = GetCurve(start, control, lastPoint);
+                                var curve = GetCurve(start, control, lastPoint, Scale);
                                 vecGlyph.Points.Data.Add(curve);
                             }
                             else
                             {
                                 // Handle non-curves
-                                IGlyphShapeData shape = CompareAdd(lastPoint, point);
+                                IGlyphShapeData shape = CompareAdd(lastPoint, point, Scale);
                                 vecGlyph.Points.Data.Add(shape);
                                 lastPoint = point;
                             }
                         }
                     }
 
-                    vecGlyph.Points.Data.Add(CompareAdd(ttfGlyph.GlyphPoints[^1], currentOutlineStartPoint));
+                    vecGlyph.Points.Data.Add(CompareAdd(ttfGlyph.GlyphPoints[^1], currentOutlineStartPoint, Scale));
                 }
+
                 vecFont.AddGlyph(vecGlyph);
             }
 
             using var outputStream = File.Create(outputVec);
             vecFont.Write(outputStream);
         }
 
-        private static IGlyphShapeData CompareAdd(GlyphPointF prev, GlyphPointF next)
+        private static IGlyphShapeData CompareAdd(GlyphPointF prev, GlyphPointF next, int scale)
         {
             if (next.X == prev.X)
             {
-                return new GlyphLine(-(next.Y - prev.Y) / Scale, GlyphAxis.Y);
+                return new GlyphLine(-(next.Y - prev.Y) / scale, GlyphAxis.Y);
             }
             else if (next.Y == prev.Y)
             {
-                return new GlyphLine((next.X - prev.X) / Scale, GlyphAxis.X);
+                return new GlyphLine((next.X - prev.X) / scale, GlyphAxis.X);
             }
             else
             {
-                return new GlyphPoint((next.X - prev.X) / Scale, -(next.Y - prev.Y) / Scale);
+                return new GlyphPoint((next.X - prev.X) / scale, -(next.Y - prev.Y) / scale);
             }
         }
 
-        private static GlyphQuadraticBezierCurve GetCurve(GlyphPointF start, GlyphPointF control, GlyphPointF end)
+        private static GlyphQuadraticBezierCurve GetCurve(GlyphPointF start, GlyphPointF control, GlyphPointF end, int scale)
         {
-            float p1X = (control.X - start.X) / Scale;
-            float p1Y = -(control.Y - start.Y) / Scale;
+            float p1X = (control.X - start.X) / scale;
+            float p1Y = -(control.Y - start.Y) / scale;
 
-            float p2X = (end.X - control.X) / Scale;
-            float p2Y = -(end.Y - control.Y) / Scale;
+            float p2X = (end.X - control.X) / scale;
+            float p2Y = -(end.Y - control.Y) / scale;
 
             return new GlyphQuadraticBezierCurve(p1X, p1Y, p2X, p2Y);
         }
diff --git a/PDTools.Files/Fonts/Glyph.cs b/PDTools.Files/Fonts/Glyph.cs
@@ -21,7 +21,7 @@ public class Glyph
 
         public ushort Flags { get; set; } = 0x8002;
         public ushort HeightOffset { get; set; }
-        public ushort AdvanceWidth { get; set; }
+        public ushort Width { get; set; }
         public GlyphShapes Points { get; set; } = new();
 
         public Glyph(char character)
@@ -43,7 +43,7 @@ public static Glyph Read(BinaryStream bs, int dataOffset)
 
             int dataLength = bs.ReadInt32();
             uint bits = bs.ReadUInt32();
-            glyph.AdvanceWidth = (ushort)(bits >> 20);
+            glyph.Width = (ushort)(bits >> 20);
             glyph.HeightOffset = (ushort)((bits >> 8) & 0b1111_11111111);
             byte calculatedRenderStrideCount = (byte)(bits & 0xFF); // Check NVectorFont.WriteGlyphs for how this is calculated
 
@@ -127,5 +127,10 @@ public Image<Rgba32> GetAsImage()
 
             return image;
         }
+
+        public override string ToString()
+        {
+            return Character.ToString();
+        }
     }
 }
diff --git a/PDTools.Files/Fonts/GlyphShapes.cs b/PDTools.Files/Fonts/GlyphShapes.cs
@@ -14,6 +14,8 @@ public class GlyphShapes
     {
         public float XMin { get; set; }
         public float YMin { get; set; }
+        public float XMax { get; set; }
+        public float YMax { get; set; }
 
         public List<IGlyphShapeData> Data { get; set; } = new();
 
@@ -200,15 +202,25 @@ public byte[] Write(BinaryStream bs)
             return buffer.ToArray();
         }
 
-        public void RecalculateMins()
+        public void RecalculateBounds()
         {
             float minX = 0, minY = 0;
+            float maxX = 0, maxY = 0;
+
             float currentX = 0, currentY = 0;
             for (int i1 = 0; i1 < Data.Count; i1++)
             {
                 IGlyphShapeData? i = Data[i1];
                 if (i is GlyphStartPoint startPoint)
                 {
+                    if (startPoint.Unk == true)
+                    {
+                        minX = startPoint.X;
+                        minY = startPoint.Y;
+                        maxX = startPoint.X;
+                        maxY = startPoint.Y;
+                    }
+                    
                     currentX = startPoint.X;
                     currentY = startPoint.Y;
                 }
@@ -235,10 +247,14 @@ public void RecalculateMins()
 
                 if (currentX < minX) minX = currentX;
                 if (currentY < minY) minY = currentY;
+                if (currentX > maxX) maxX = currentX;
+                if (currentY > maxY) maxY = currentY;
             }
 
             XMin = minX;
             YMin = minY;
+            XMax = maxX;
+            YMax = maxY;
         }
 
         private static float BitValueToFloat(long value, int bitCount)
diff --git a/PDTools.Files/Fonts/NVectorFont.cs b/PDTools.Files/Fonts/NVectorFont.cs
@@ -160,7 +160,7 @@ private void WriteGlyphs(BinaryStream bs)
                 bs.WriteInt32(glyphDataSize);
 
                 uint bits = 0;
-                bits |= (uint)((glyph.AdvanceWidth & 0b1111_11111111) << 20); // 12 bits
+                bits |= (uint)((glyph.Width & 0b1111_11111111) << 20); // 12 bits
                 bits |= (uint)((glyph.HeightOffset & 0b1111_11111111) << 8); // 12 bits
                 bits |= (uint)((glyphDataSize + 0x1F) / 0x10 & 0b11111111); // 8 bit
                 bs.WriteUInt32(bits);
@@ -177,12 +177,18 @@ private void WriteGlyphs(BinaryStream bs)
             bs.Position = lastGlyphDataOffset;
         }
 
+        /// <summary>
+        /// Adds the glyph to the font (and recalculates the glyph's bounds/width)
+        /// </summary>
+        /// <param name="glyph"></param>
+        /// <exception cref="Exception"></exception>
         public void AddGlyph(Glyph glyph)
         {
             if (Characters.Contains(glyph.Character))
                 throw new Exception($"Glyph '{glyph.Character}' already exists");
 
-            glyph.Points.RecalculateMins();
+            glyph.Points.RecalculateBounds();
+            glyph.Width = (ushort)(glyph.Points.XMax - glyph.Points.XMin);
 
             Characters.Add(glyph.Character);
             Glyphs.Add(glyph);
diff --git a/PDTools.Files/PDTools.Files.csproj b/PDTools.Files/PDTools.Files.csproj
@@ -20,6 +20,4 @@
     <ProjectReference Include="..\PDTools.Utils\PDTools.Utils.csproj" />
   </ItemGroup>
 
-  <Import Project="..\Typography\Typography.OpenFont\Typography.OpenFont.projitems" Label="Shared" />
-
 </Project>
diff --git a/PDTools.GTPatcher/GT7AppOpt.txt b/PDTools.GTPatcher/GT7AppOpt.txt
@@ -96,4 +96,33 @@ rtext_debug
 demo_idx
 
 // >1.00 (seen in 1.25)
-emotional
+emotional
+
+reward_ce_course
+autodemo_pause_time
+autodemo_return_time
+autodemo_entry_num
+autodemo_group
+autodemo_course
+autodemo_track_weather_id
+no_bandwidth
+lobby_auto_entry
+debug_entry_channel
+online_race_host
+online_race_join_as_spectator
+OnlineGameMode
+livery_share_file
+scapes_open
+scapes1
+scene_preview_mode
+scene_preview_seq
+event2
+trade_in
+virtual_paddock
+virtual_paddock_no_car_share
+rtext_develop
+birthdaygift
+livery_special_decken
+skip_online_title_movie
+enable_bridge_on_steward
+vr_showroom_open
diff --git a/PDTools.sln b/PDTools.sln
@@ -41,6 +41,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PDTools.GTPatcher", "PDTool
 EndProject
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Typography.OpenFont", "Typography\Typography.OpenFont\Typography.OpenFont.shproj", "{235A071B-8D06-40AE-A5C5-B1CE59715EE9}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PDTools.Files.Fonts.NVecBuilder", "PDTools.Files.Fonts.NVecBuilder\PDTools.Files.Fonts.NVecBuilder.csproj", "{A5CD16E0-AEE4-4656-AD47-717EA915B909}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -119,10 +121,10 @@ Global
 		{39FA31E3-6088-437C-9697-C86CABFFF733}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{39FA31E3-6088-437C-9697-C86CABFFF733}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{39FA31E3-6088-437C-9697-C86CABFFF733}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D585EDFC-C144-486F-BCB9-2991534D8E9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D585EDFC-C144-486F-BCB9-2991534D8E9E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D585EDFC-C144-486F-BCB9-2991534D8E9E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D585EDFC-C144-486F-BCB9-2991534D8E9E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A5CD16E0-AEE4-4656-AD47-717EA915B909}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A5CD16E0-AEE4-4656-AD47-717EA915B909}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A5CD16E0-AEE4-4656-AD47-717EA915B909}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A5CD16E0-AEE4-4656-AD47-717EA915B909}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -132,7 +134,6 @@ Global
 	EndGlobalSection
 	GlobalSection(SharedMSBuildProjectFiles) = preSolution
 		Typography\Typography.OpenFont\Typography.OpenFont.projitems*{235a071b-8d06-40ae-a5c5-b1ce59715ee9}*SharedItemsImports = 13
-		Typography\Typography.OpenFont\Typography.OpenFont.projitems*{72d26fba-e068-43ae-b5c1-492e45586c13}*SharedItemsImports = 5
-		Typography\Typography.OpenFont\Typography.OpenFont.projitems*{d585edfc-c144-486f-bcb9-2991534d8e9e}*SharedItemsImports = 5
+		Typography\Typography.OpenFont\Typography.OpenFont.projitems*{a5cd16e0-aee4-4656-ad47-717ea915b909}*SharedItemsImports = 5
 	EndGlobalSection
 EndGlobal

Original file line number	Diff line number	Diff line change
`@@ -10,17 +10,15 @@`
`10`	`10`	`using TTFGlyph = Typography.OpenFont.Glyph;`
`11`	`11`	`using NVecGlyph = PDTools.Files.Fonts.Glyph;`
`12`	`12`
`13`		`-namespace PDTools.Files.Fonts`
	`13`	`+namespace PDTools.Files.Fonts.NVecBuilder`
`14`	`14`	`{`
`15`	`15`	`public class TrueTypeToNVecConverter`
`16`	`16`	`{`
`17`		`- /* Some notes:`
`18`		`- * May not be the prettiest conversion code, Y is also swapped around`
`19`		`- * "/ 2" is hardcoded for 2048 units per em fonts */`
`20`		`-`
`21`		`- public static int Scale { get; set; } = 2;`
`22`	`17`	`public static void Convert(string inputTtf, string outputVec)`
`23`	`18`	`{`
	`19`	`+ if (Path.GetExtension(inputTtf) == ".otf")`
	`20`	`+ throw new NotSupportedException("otf (OpenType) is not supported (incompatible curves).");`
	`21`	`+`
`24`	`22`	`using var ttf = File.OpenRead(inputTtf);`
`25`	`23`	`Typeface ttfFont = new OpenFontReader().Read(ttf);`
`26`	`24`
`@@ -30,22 +28,26 @@ public static void Convert(string inputTtf, string outputVec)`
`30`	`28`	`ttfFont.CollectUnicode(unicodes);`
`31`	`29`	`unicodes = unicodes.Distinct().ToList();`
`32`	`30`
	`31`	`+ Console.WriteLine($"TTF: {unicodes.Count} unicode characters");`
	`32`	`+ Console.WriteLine($"TTF: {ttfFont.UnitsPerEm} units per em");`
	`33`	`+`
	`34`	`+ int Scale = ttfFont.UnitsPerEm > 1024 ? ttfFont.UnitsPerEm / 1024 : 1;`
	`35`	`+`
`33`	`36`	`foreach (var codePoint in unicodes)`
`34`	`37`	`{`
`35`	`38`	`if (codePoint == 0)`
`36`	`39`	`continue;`
`37`	`40`
`38`	`41`	`ushort glyphIndex = ttfFont.GetGlyphIndex((int)codePoint);`
`39`	`42`	`TTFGlyph ttfGlyph = ttfFont.GetGlyph(glyphIndex);`
`40`		`-`
`41`	`43`	`NVecGlyph vecGlyph = new NVecGlyph((char)codePoint);`
`42`		`- vecGlyph.AdvanceWidth = (ushort)(ttfFont.GetAdvanceWidthFromGlyphIndex((ushort)glyphIndex) / Scale);`
	`44`	`+`
	`45`	`+ Console.WriteLine($"TTF: Processing '{(char)codePoint}' ({codePoint:X4}) with {ttfGlyph.GlyphPoints.Length} points");`
`43`	`46`
`44`	`47`	`int offset = ttfFont.Bounds.YMax - ttfGlyph.Bounds.YMax;`
`45`	`48`	`vecGlyph.HeightOffset = (ushort)(offset / Scale);`
`46`	`49`
`47`	`50`	`Span<ushort> endPoints = ttfGlyph.EndPoints.AsSpan();`
`48`		`-`
`49`	`51`	`GlyphPointF lastPoint = default;`
`50`	`52`
`51`	`53`	`if (ttfGlyph.GlyphPoints.Any())`
`@@ -64,7 +66,7 @@ public static void Convert(string inputTtf, string outputVec)`
`64`	`66`	`var prev = ttfGlyph.GlyphPoints[i - 1];`
`65`	`67`	`if (prev.onCurve)`
`66`	`68`	`{`
`67`		`- IGlyphShapeData shape = CompareAdd(prev, currentOutlineStartPoint);`
	`69`	`+ IGlyphShapeData shape = CompareAdd(prev, currentOutlineStartPoint, Scale);`
`68`	`70`	`vecGlyph.Points.Data.Add(shape);`
`69`	`71`	`}`
`70`	`72`	`}`
`@@ -109,51 +111,52 @@ public static void Convert(string inputTtf, string outputVec)`
`109`	`111`	`}`
`110`	`112`	`}`
`111`	`113`
`112`		`- var curve = GetCurve(start, control, lastPoint);`
	`114`	`+ var curve = GetCurve(start, control, lastPoint, Scale);`
`113`	`115`	`vecGlyph.Points.Data.Add(curve);`
`114`	`116`	`}`
`115`	`117`	`else`
`116`	`118`	`{`
`117`	`119`	`// Handle non-curves`
`118`		`- IGlyphShapeData shape = CompareAdd(lastPoint, point);`
	`120`	`+ IGlyphShapeData shape = CompareAdd(lastPoint, point, Scale);`
`119`	`121`	`vecGlyph.Points.Data.Add(shape);`
`120`	`122`	`lastPoint = point;`
`121`	`123`	`}`
`122`	`124`	`}`
`123`	`125`	`}`
`124`	`126`
`125`		`- vecGlyph.Points.Data.Add(CompareAdd(ttfGlyph.GlyphPoints[^1], currentOutlineStartPoint));`
	`127`	`+ vecGlyph.Points.Data.Add(CompareAdd(ttfGlyph.GlyphPoints[^1], currentOutlineStartPoint, Scale));`
`126`	`128`	`}`
	`129`	`+`
`127`	`130`	`vecFont.AddGlyph(vecGlyph);`
`128`	`131`	`}`
`129`	`132`
`130`	`133`	`using var outputStream = File.Create(outputVec);`
`131`	`134`	`vecFont.Write(outputStream);`
`132`	`135`	`}`
`133`	`136`
`134`		`- private static IGlyphShapeData CompareAdd(GlyphPointF prev, GlyphPointF next)`
	`137`	`+ private static IGlyphShapeData CompareAdd(GlyphPointF prev, GlyphPointF next, int scale)`
`135`	`138`	`{`
`136`	`139`	`if (next.X == prev.X)`
`137`	`140`	`{`
`138`		`- return new GlyphLine(-(next.Y - prev.Y) / Scale, GlyphAxis.Y);`
	`141`	`+ return new GlyphLine(-(next.Y - prev.Y) / scale, GlyphAxis.Y);`
`139`	`142`	`}`
`140`	`143`	`else if (next.Y == prev.Y)`
`141`	`144`	`{`
`142`		`- return new GlyphLine((next.X - prev.X) / Scale, GlyphAxis.X);`
	`145`	`+ return new GlyphLine((next.X - prev.X) / scale, GlyphAxis.X);`
`143`	`146`	`}`
`144`	`147`	`else`
`145`	`148`	`{`
`146`		`- return new GlyphPoint((next.X - prev.X) / Scale, -(next.Y - prev.Y) / Scale);`
	`149`	`+ return new GlyphPoint((next.X - prev.X) / scale, -(next.Y - prev.Y) / scale);`
`147`	`150`	`}`
`148`	`151`	`}`
`149`	`152`
`150`		`- private static GlyphQuadraticBezierCurve GetCurve(GlyphPointF start, GlyphPointF control, GlyphPointF end)`
	`153`	`+ private static GlyphQuadraticBezierCurve GetCurve(GlyphPointF start, GlyphPointF control, GlyphPointF end, int scale)`
`151`	`154`	`{`
`152`		`- float p1X = (control.X - start.X) / Scale;`
`153`		`- float p1Y = -(control.Y - start.Y) / Scale;`
	`155`	`+ float p1X = (control.X - start.X) / scale;`
	`156`	`+ float p1Y = -(control.Y - start.Y) / scale;`
`154`	`157`
`155`		`- float p2X = (end.X - control.X) / Scale;`
`156`		`- float p2Y = -(end.Y - control.Y) / Scale;`
	`158`	`+ float p2X = (end.X - control.X) / scale;`
	`159`	`+ float p2Y = -(end.Y - control.Y) / scale;`
`157`	`160`
`158`	`161`	`return new GlyphQuadraticBezierCurve(p1X, p1Y, p2X, p2Y);`
`159`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@ public class GlyphShapes`
`14`	`14`	`{`
`15`	`15`	`public float XMin { get; set; }`
`16`	`16`	`public float YMin { get; set; }`
	`17`	`+ public float XMax { get; set; }`
	`18`	`+ public float YMax { get; set; }`
`17`	`19`
`18`	`20`	`public List<IGlyphShapeData> Data { get; set; } = new();`
`19`	`21`
`@@ -200,15 +202,25 @@ public byte[] Write(BinaryStream bs)`
`200`	`202`	`return buffer.ToArray();`
`201`	`203`	`}`
`202`	`204`
`203`		`- public void RecalculateMins()`
	`205`	`+ public void RecalculateBounds()`
`204`	`206`	`{`
`205`	`207`	`float minX = 0, minY = 0;`
	`208`	`+ float maxX = 0, maxY = 0;`
	`209`	`+`
`206`	`210`	`float currentX = 0, currentY = 0;`
`207`	`211`	`for (int i1 = 0; i1 < Data.Count; i1++)`
`208`	`212`	`{`
`209`	`213`	`IGlyphShapeData? i = Data[i1];`
`210`	`214`	`if (i is GlyphStartPoint startPoint)`
`211`	`215`	`{`
	`216`	`+ if (startPoint.Unk == true)`
	`217`	`+ {`
	`218`	`+ minX = startPoint.X;`
	`219`	`+ minY = startPoint.Y;`
	`220`	`+ maxX = startPoint.X;`
	`221`	`+ maxY = startPoint.Y;`
	`222`	`+ }`
	`223`	`+`
`212`	`224`	`currentX = startPoint.X;`
`213`	`225`	`currentY = startPoint.Y;`
`214`	`226`	`}`
`@@ -235,10 +247,14 @@ public void RecalculateMins()`
`235`	`247`
`236`	`248`	`if (currentX < minX) minX = currentX;`
`237`	`249`	`if (currentY < minY) minY = currentY;`
	`250`	`+ if (currentX > maxX) maxX = currentX;`
	`251`	`+ if (currentY > maxY) maxY = currentY;`
`238`	`252`	`}`
`239`	`253`
`240`	`254`	`XMin = minX;`
`241`	`255`	`YMin = minY;`
	`256`	`+ XMax = maxX;`
	`257`	`+ YMax = maxY;`
`242`	`258`	`}`
`243`	`259`
`244`	`260`	`private static float BitValueToFloat(long value, int bitCount)`