RFC: Support for TrueType/OpenType fonts

osu.Framework.Benchmarks/BenchmarkOutlineFontLoading.cs

@@ -0,0 +1,62 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Diagnostics;
+using System.Reflection;
+using BenchmarkDotNet.Attributes;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.IO.Stores;
+using SixLabors.ImageSharp.Memory;
+
+namespace osu.Framework.Benchmarks
+{
+    public class BenchmarkOutlineFontLoading : BenchmarkTest
+    {
+        private NamespacedResourceStore<byte[]> baseResources = null!;
+
+        public override void SetUp()
+        {
+            SixLabors.ImageSharp.Configuration.Default.MemoryAllocator = MemoryAllocator.Default;
+
+            baseResources = new NamespacedResourceStore<byte[]>(new DllResourceStore(@"osu.Framework.Benchmarks.dll"), @"Resources");
+        }
+
+        [Params(1, 10, 100, 1000, 10000)]
+        public int FetchCount;
+
+        private const string font_name = @"Fonts/FontAwesome5/FontAwesome-Solid";
+
+        [Benchmark(Baseline = true)]
+        public void BenchmarkNoCache()
+        {
+            using (var store = new OutlineGlyphStore(baseResources, font_name))
+                runFor(store);
+        }
+
+        private void runFor(OutlineGlyphStore store)
+        {
+            store.LoadFontAsync().WaitSafely();
+
+            var props = typeof(FontAwesome.Solid).GetProperties(BindingFlags.Public | BindingFlags.Static);
+
+            int remainingCount = FetchCount;
+
+            while (true)
+            {
+                foreach (var p in props)
+                {
+                    object? propValue = p.GetValue(null);
+                    Debug.Assert(propValue != null);
+
+                    var icon = (IconUsage)propValue;
+                    using (var upload = store.Get(icon.Icon.ToString()))
+                        Trace.Assert(upload.Data != null);
+
+                    if (remainingCount-- == 0)
+                        return;
+                }
+            }
+        }
+    }
+}

osu.Framework.Tests/IO/FontStoreTest.cs

@@ -4,7 +4,6 @@
 #nullable disable
 
 using NUnit.Framework;
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Rendering.Dummy;
 using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
@@ -22,7 +21,7 @@ public class FontStoreTest
         public void OneTimeSetUp()
         {
             storage = new TemporaryNativeStorage("fontstore-test");
-            fontResourceStore = new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Drawable).Assembly), "Resources.Fonts.Roboto");
+            fontResourceStore = new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(FontStoreTest).Assembly), "Resources.Fonts.Roboto");
         }
 
         [Test]

osu.Framework.Tests/IO/TextureStoreTest.cs

@@ -3,7 +3,6 @@
 
 using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Graphics;
 using osu.Framework.Graphics.Rendering.Dummy;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
@@ -18,7 +17,7 @@ public class TextureStoreTest
         [OneTimeSetUp]
         public void OneTimeSetUp()
         {
-            fontResourceStore = new TextureLoaderStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Drawable).Assembly), "Resources/Fonts"));
+            fontResourceStore = new TextureLoaderStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(TextureStoreTest).Assembly), "Resources/Fonts"));
         }
 
         [Test]

osu.Framework.Tests/Text/FontVariationTest.cs

@@ -0,0 +1,125 @@
+
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.IO.Stores;
+using osu.Framework.Text;
+
+namespace osu.Framework.Tests.Text
+{
+    [TestFixture]
+    public class FontVariationTest
+    {
+        private OutlineFont outlineFont = null!;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            outlineFont = new OutlineFont(
+                new NamespacedResourceStore<byte[]>(
+                    new DllResourceStore(typeof(Game).Assembly), @"Resources"
+                ),
+                "Fonts/Roboto/Roboto"
+            );
+
+            outlineFont.LoadAsync().WaitSafely();
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            outlineFont.Dispose();
+        }
+
+        [Test]
+        public void TestAxes()
+        {
+            var variation = new FontVariation
+            {
+                Axes = new Dictionary<string, double>
+                {
+                    { @"wght", 123 },
+                    { @"wdth", 78.5 },
+                },
+            };
+
+            Assert.AreEqual(variation.GenerateInstanceName(@"Roboto"), @"Roboto_123wght_78.5wdth");
+
+            var rawVariation = outlineFont.DecodeFontVariation(variation);
+            Assert.NotNull(rawVariation);
+            Assert.NotZero(rawVariation!.Axes.Length);
+            Assert.Zero(rawVariation.NamedInstance);
+        }
+
+        [Test]
+        public void TestNamedInstance()
+        {
+            var variation = new FontVariation
+            {
+                NamedInstance = "Roboto-Regular",
+            };
+
+            Assert.AreEqual(variation.GenerateInstanceName(@"Roboto"), @"Roboto-Regular");
+            Assert.AreEqual(variation.GenerateInstanceName(@"some other font"), @"Roboto-Regular");
+
+            var rawVariation = outlineFont.DecodeFontVariation(variation);
+            Assert.NotNull(rawVariation);
+            Assert.Zero(rawVariation!.Axes.Length);
+            Assert.NotZero(rawVariation.NamedInstance);
+        }
+
+        [Test]
+        public void TestAxesOverrideNamedInstance()
+        {
+            var variation = new FontVariation
+            {
+                Axes = new Dictionary<string, double> { { @"wght", 123 } },
+                NamedInstance = "Roboto-Regular",
+            };
+
+            Assert.AreEqual(variation.GenerateInstanceName(@"Roboto"), @"Roboto_123wght");
+
+            var rawVariation = outlineFont.DecodeFontVariation(variation);
+            Assert.NotNull(rawVariation);
+            Assert.NotZero(rawVariation!.Axes.Length);
+            Assert.Zero(rawVariation.NamedInstance);
+        }
+
+        [Test]
+        public void TestNull()
+        {
+            var rawVariation = outlineFont.DecodeFontVariation(null);
+            Assert.Null(rawVariation);
+        }
+
+        [Test]
+        public void TestManyAxes()
+        {
+            var variation = new FontVariation
+            {
+                Axes = new Dictionary<string, double>
+                {
+                    { @"wght", 1000 },
+                    { @"wdth", 50.12345 },
+                    { @"opsz", 12 },
+                    { @"GRAD", -100 },
+                    { @"slnt", -10 },
+                    { @"XTRA", 456.78901 },
+                    { @"XOPQ", 34.56789 },
+                    { @"YOPQ", 56.78901 },
+                    { @"YTLC", 500.12345 },
+                    { @"YTUC", 600.12345 },
+                    { @"YTAS", 700.12345 },
+                    { @"YTDE", -555.55555 },
+                    { @"YTFI", 600.12345 },
+                },
+            };
+
+            const string expected = @"RobotoFlex-F8439096C93C09CF75D5DC6A16A20B99E7A65C932EC1E18731F74415AA77DCDB";
+            Assert.AreEqual(variation.GenerateInstanceName(@"RobotoFlex"), expected);
+        }
+    }
+}

osu.Framework.Tests/Text/OutlineFontTest.cs

@@ -0,0 +1,87 @@
+
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Extensions;
+using osu.Framework.IO.Stores;
+using osu.Framework.Text;
+
+namespace osu.Framework.Tests.Text
+{
+    [TestFixture]
+    public class OutlineFontTest
+    {
+        private OutlineFont outlineFont = null!;
+        private RawFontVariation? variation;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            outlineFont = new OutlineFont(
+                new NamespacedResourceStore<byte[]>(
+                    new DllResourceStore(typeof(Game).Assembly), @"Resources"
+                ),
+                @"Fonts/Roboto/Roboto"
+            );
+            outlineFont.LoadAsync().WaitSafely();
+
+            variation = outlineFont.DecodeFontVariation(new FontVariation
+            {
+                NamedInstance = @"Roboto-Regular",
+            });
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            outlineFont.Dispose();
+        }
+
+        [Test]
+        public void TestGetGlyphIndex()
+        {
+            Assert.NotZero(outlineFont.GetGlyphIndex('A'));
+            Assert.Zero(outlineFont.GetGlyphIndex('\ufffe'));
+        }
+
+        [Test]
+        public void TestGetMetrics()
+        {
+            uint glyph = outlineFont.GetGlyphIndex('A');
+            var metrics = outlineFont.GetMetrics(glyph, variation);
+
+            Assert.NotNull(metrics);
+            Assert.AreEqual(metrics!.Character, '\uffff');
+
+            Assert.Null(outlineFont.GetMetrics(int.MaxValue, variation));
+        }
+
+        [Test]
+        public void TestGlyphStores()
+        {
+            using (var regular = new OutlineGlyphStore(outlineFont, @"Roboto-Regular"))
+            using (var bold = new OutlineGlyphStore(outlineFont, @"Roboto-Bold"))
+            {
+                var regularA = regular.Get('A');
+                var boldA = bold.Get('A');
+                Assert.NotNull(regularA);
+                Assert.NotNull(boldA);
+
+                Assert.AreNotEqual(regularA, boldA);
+
+                // the same OutlineGlyphStore should return identical
+                // metrics for the same character (required as a single
+                // OutlineFont can be shared by multiple OutlineGlyphStores)
+                var regularA2 = regular.Get('A');
+                Assert.NotNull(regularA2);
+
+                Assert.AreEqual(regularA!.Character, regularA2!.Character);
+                Assert.AreEqual(regularA.Baseline, regularA2.Baseline);
+                Assert.AreEqual(regularA.XOffset, regularA2.XOffset);
+                Assert.AreEqual(regularA.YOffset, regularA2.YOffset);
+                Assert.AreEqual(regularA.XAdvance, regularA2.XAdvance);
+            }
+        }
+    }
+}

osu.Framework.Tests/Text/TextBuilderTest.cs

@@ -35,7 +35,7 @@ public class TextBuilderTest
         public void SetUp()
         {
             fontStore = new FontStore(new DummyRenderer(), useAtlas: false);
-            fontStore.AddTextureSource(new GlyphStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Game).Assembly), @"Resources"), "Fonts/Roboto/Roboto-Regular"));
+            fontStore.AddTextureSource(new GlyphStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(TextBuilderTest).Assembly), @"Resources"), "Fonts/Roboto/Roboto-Regular"));
             fontStore.AddTextureSource(new GlyphStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Game).Assembly), @"Resources"), "Fonts/FontAwesome5/FontAwesome-Solid"));
 
             glyphA = fontStore.Get(null, 'a').AsNonNull();

osu.Framework/Game.cs

@@ -207,14 +207,16 @@ private void load(FrameworkConfigManager config)
             Fonts.AddStore(localFonts = new FontStore(Host.Renderer, useAtlas: false));
 
             // Roboto (FrameworkFont.Regular)
-            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-Regular");
-            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-RegularItalic");
-            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-Bold");
-            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-BoldItalic");
+            var roboto = AddVariableFont(Resources, @"Fonts/Roboto/Roboto", localFonts);
+            roboto.AddInstance(@"Roboto-Regular");
+            roboto.AddInstance(@"Roboto-Bold");
+            var robotoItalic = AddVariableFont(Resources, @"Fonts/Roboto/RobotoItalic", localFonts);
+            robotoItalic.AddInstance(@"Roboto-Italic", @"Roboto-RegularItalic");
+            robotoItalic.AddInstance(@"Roboto-BoldItalic");
 
             // RobotoCondensed (FrameworkFont.Condensed)
-            addFont(localFonts, Resources, @"Fonts/RobotoCondensed/RobotoCondensed-Regular");
-            addFont(localFonts, Resources, @"Fonts/RobotoCondensed/RobotoCondensed-Bold");
+            roboto.AddInstance(@"Roboto-CondensedRegular", @"RobotoCondensed-Regular");
+            roboto.AddInstance(@"Roboto-CondensedBold", @"RobotoCondensed-Bold");
 
             addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Solid");
             addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Regular");
@@ -257,7 +259,7 @@ private void load(FrameworkConfigManager config)
         protected virtual OnlineStore CreateOnlineStore() => new OnlineStore();
 
         /// <summary>
-        /// Add a font to be globally accessible to the game.
+        /// Add a bitmap font to be globally accessible to the game.
         /// </summary>
         /// <param name="store">The backing store with font resources.</param>
         /// <param name="assetName">The base name of the font.</param>
@@ -268,6 +270,35 @@ public void AddFont(ResourceStore<byte[]> store, string assetName = null, FontSt
         private void addFont(FontStore target, ResourceStore<byte[]> store, string assetName = null)
             => target.AddTextureSource(new RawCachingGlyphStore(store, assetName, Host.CreateTextureLoaderStore(store)));
 
+        /// <summary>
+        /// Add an outline font to be globally accessible to the game.
+        /// </summary>
+        /// <param name="store">The backing store with font resources.</param>
+        /// <param name="assetName">The base name of the font.</param>
+        /// <param name="target">An optional target store to add the font to. If not specified, <see cref="Fonts"/> is used.</param>
+        /// <returns>The newly added font family from which fonts can be instantiated.</returns>
+        public void AddOutlineFont(ResourceStore<byte[]> store, string assetName, FontStore target = null)
+            => (target ?? Fonts).AddTextureSource(new OutlineGlyphStore(store, assetName));
+
+        /// <summary>
+        /// Add a variable font to be globally accessible to the game.
+        /// </summary>
+        /// <remarks>
+        /// This does not instantiate any glyph stores. Use
+        /// <see cref="OutlineFontStore.AddInstance(string, string?)"/>
+        /// on the returned font store to make the font usable.
+        /// </remarks>
+        /// <param name="store">The backing store with font resources.</param>
+        /// <param name="assetName">The base name of the font.</param>
+        /// <param name="target">An optional target store to add the font to. If not specified, <see cref="Fonts"/> is used.</param>
+        /// <returns>The newly added font family from which fonts can be instantiated.</returns>
+        public OutlineFontStore AddVariableFont(ResourceStore<byte[]> store, string assetName, FontStore target = null)
+        {
+            var nestedStore = new OutlineFontStore(Host.Renderer, store, assetName);
+            (target ?? Fonts).AddStore(nestedStore);
+            return nestedStore;
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();