Merge pull request #6598 from frenzibyte/fix-text-builder

Preserve weight and italics when falling back to other fonts in text rendering

Author: smoogipoo

osu.Framework.Tests/Text/TextBuilderTest.cs

@@ -559,17 +559,61 @@ public void TestSameCharacterFallsBackWithNoFontName()
             var font = new FontUsage("test", size: font_size);
             var nullFont = new FontUsage(null);
             var builder = new TextBuilder(new TestStore(
-                new GlyphEntry(font, new TestGlyph('b', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(nullFont, new TestGlyph('a', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(font, new TestGlyph('?', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(nullFont, new TestGlyph('?', 0, 0, 0, 0, 0, 0, 0))
+                new GlyphEntry(font, new TestGlyph('b')),
+                new GlyphEntry(nullFont, new TestGlyph('a')),
+                new GlyphEntry(font, new TestGlyph('?')),
+                new GlyphEntry(nullFont, new TestGlyph('?'))
             ), font);
 
             builder.AddText("a");
 
             Assert.That(builder.Characters[0].Character, Is.EqualTo('a'));
         }
 
+        /// <summary>
+        /// Tests that glyph lookup falls back to using the same character with a different font but same weight.
+        /// </summary>
+        [Test]
+        public void TestSameCharacterFallsBackToDifferentFontWithSameWeight()
+        {
+            var font1B = new FontUsage("test1", weight: "Bold", size: font_size);
+            var font2B = new FontUsage("test2", weight: "Bold", size: font_size);
+            var font2R = new FontUsage("test2", weight: "Regular", size: font_size);
+
+            var builder = new TextBuilder(new TestStore(
+                new GlyphEntry(font1B, new TestGlyph('b', fontName: font1B.FontName)),
+                new GlyphEntry(font2R, new TestGlyph('a', fontName: font2R.FontName)),
+                new GlyphEntry(font2B, new TestGlyph('a', fontName: font2B.FontName))
+            ), font1B);
+
+            builder.AddText("a");
+
+            Assert.That(builder.Characters[0].Character, Is.EqualTo('a'));
+            Assert.That(((TestGlyph)builder.Characters[0].Glyph).FontName, Is.EqualTo("test2-Bold"));
+        }
+
+        /// <summary>
+        /// Tests that glyph lookup falls back to using the same character with a different font but italics are preserved.
+        /// </summary>
+        [Test]
+        public void TestSameCharacterFallsBackToDifferentFontWithItalics()
+        {
+            var font1I = new FontUsage("test1", italics: true, size: font_size);
+            var font2I = new FontUsage("test2", italics: true, size: font_size);
+            var font2R = new FontUsage("test2", italics: false, size: font_size);
+
+            var builder = new TextBuilder(new TestStore(
+                new GlyphEntry(font1I, new TestGlyph('b', fontName: font1I.FontName)),
+                new GlyphEntry(font2R, new TestGlyph('a', fontName: font2R.FontName)),
+                new GlyphEntry(font2I, new TestGlyph('a', fontName: font2I.FontName))
+            ), font1I);
+
+            builder.AddText("a");
+
+            Assert.That(builder.Characters[0].Character, Is.EqualTo('a'));
+            Assert.That(((TestGlyph)builder.Characters[0].Glyph).FontName, Is.EqualTo("test2-Italic"));
+        }
+
         /// <summary>
         /// Tests that glyph lookup falls back to using the fallback character with the provided font name.
         /// </summary>
@@ -579,10 +623,10 @@ public void TestFallBackCharacterFallsBackWithFontName()
             var font = new FontUsage("test", size: font_size);
             var nullFont = new FontUsage(null);
             var builder = new TextBuilder(new TestStore(
-                new GlyphEntry(font, new TestGlyph('b', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(nullFont, new TestGlyph('b', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(font, new TestGlyph('?', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(nullFont, new TestGlyph('?', 1, 0, 0, 0, 0, 0, 0))
+                new GlyphEntry(font, new TestGlyph('b')),
+                new GlyphEntry(nullFont, new TestGlyph('b')),
+                new GlyphEntry(font, new TestGlyph('?')),
+                new GlyphEntry(nullFont, new TestGlyph('?', 1))
             ), font);
 
             builder.AddText("a");
@@ -600,10 +644,10 @@ public void TestFallBackCharacterFallsBackWithNoFontName()
             var font = new FontUsage("test", size: font_size);
             var nullFont = new FontUsage(null);
             var builder = new TextBuilder(new TestStore(
-                new GlyphEntry(font, new TestGlyph('b', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(nullFont, new TestGlyph('b', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(font, new TestGlyph('b', 0, 0, 0, 0, 0, 0, 0)),
-                new GlyphEntry(nullFont, new TestGlyph('?', 1, 0, 0, 0, 0, 0, 0))
+                new GlyphEntry(font, new TestGlyph('b')),
+                new GlyphEntry(nullFont, new TestGlyph('b')),
+                new GlyphEntry(font, new TestGlyph('b')),
+                new GlyphEntry(nullFont, new TestGlyph('?', 1))
             ), font);
 
             builder.AddText("a");
@@ -653,7 +697,7 @@ public ITexturedCharacterGlyph Get(string? fontName, char character)
                 if (string.IsNullOrEmpty(fontName))
                     return glyphs.FirstOrDefault(g => g.Glyph.Character == character).Glyph;
 
-                return glyphs.FirstOrDefault(g => g.Font.FontName == fontName && g.Glyph.Character == character).Glyph;
+                return glyphs.FirstOrDefault(g => g.Font.FontName.EndsWith(fontName, StringComparison.Ordinal) && g.Glyph.Character == character).Glyph;
             }
 
             public Task<ITexturedCharacterGlyph?> GetAsync(string fontName, char character) => throw new NotImplementedException();
@@ -681,10 +725,11 @@ public GlyphEntry(FontUsage font, ITexturedCharacterGlyph glyph)
             public float Baseline { get; }
             public float Height { get; }
             public char Character { get; }
+            public string? FontName { get; }
 
             private readonly float glyphKerning;
 
-            public TestGlyph(char character, float xOffset, float yOffset, float xAdvance, float width, float baseline, float height, float kerning)
+            public TestGlyph(char character, float xOffset = 0, float yOffset = 0, float xAdvance = 0, float width = 0, float baseline = 0, float height = 0, float kerning = 0, string? fontName = null)
             {
                 glyphKerning = kerning;
                 Character = character;
@@ -694,6 +739,7 @@ public TestGlyph(char character, float xOffset, float yOffset, float xAdvance, f
                 Width = width;
                 Baseline = baseline;
                 Height = height;
+                FontName = fontName;
             }
 
             public float GetKerning<T>(T lastGlyph)

osu.Framework/Graphics/Sprites/FontUsage.cs

@@ -59,6 +59,19 @@ namespace osu.Framework.Graphics.Sprites
         [NotNull]
         public string FontName { get; }
 
+        /// <summary>
+        /// The part of <see cref="FontName"/> directly after <see cref="Family"/>,
+        /// used for looking up other font families sharing same weight/italics specifications.
+        /// </summary>
+        /// <remarks>
+        /// The format is of the form: <br />
+        /// (empty) <br />
+        /// -Italic <br />
+        /// -{Weight}Italic
+        /// </remarks>
+        [NotNull]
+        public string FontNameNoFamily { get; }
+
         /// <summary>
         /// Creates an instance of <see cref="FontUsage"/> using the specified font <paramref name="family"/>, font <paramref name="weight"/> and a value indicating whether the used font is italic or not.
         /// </summary>
@@ -76,13 +89,16 @@ public FontUsage([CanBeNull] string family = null, float size = default_text_siz
             FixedWidth = fixedWidth;
 
             FontName = Family + "-";
+
             if (!string.IsNullOrEmpty(weight))
                 FontName += weight;
 
             if (italics)
                 FontName += "Italic";
 
             FontName = FontName.TrimEnd('-');
+
+            FontNameNoFamily = string.IsNullOrEmpty(Family) ? FontName : FontName.Substring(Family.Length);
         }
 
         /// <summary>

osu.Framework/IO/Stores/FontStore.cs

@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -144,12 +145,13 @@ public ITexturedCharacterGlyph Get(string fontName, char character)
             if (namespacedGlyphCache.TryGetValue(key, out var existing))
                 return existing;
 
-            string textureName = string.IsNullOrEmpty(fontName) ? character.ToString() : $"{fontName}/{character}";
-
             foreach (var store in glyphStores)
             {
-                if ((string.IsNullOrEmpty(fontName) || fontName == store.FontName) && store.HasGlyph(character))
+                if (store.FontName.EndsWith(fontName ?? string.Empty, StringComparison.Ordinal) && store.HasGlyph(character))
+                {
+                    string textureName = $"{store.FontName}/{character}";
                     return namespacedGlyphCache[key] = new TexturedCharacterGlyph(store.Get(character).AsNonNull(), Get(textureName), 1 / ScaleAdjust);
+                }
             }
 
             foreach (var store in nestedFontStores)

osu.Framework/Text/ITexturedGlyphLookupStore.cs

@@ -10,15 +10,17 @@ public interface ITexturedGlyphLookupStore
         /// <summary>
         /// Retrieves a glyph from the store.
         /// </summary>
-        /// <param name="fontName">The name of the font.</param>
+        /// <param name="fontName">The name of the font. Alternatively, a suffix of the name can be provided to search for the nearest font matching the given suffix.
+        /// This is used to look up a glyph in any font while requiring certain weight / italics specifications.</param>
         /// <param name="character">The character to retrieve.</param>
         /// <returns>The character glyph.</returns>
         ITexturedCharacterGlyph? Get(string? fontName, char character);
 
         /// <summary>
         /// Retrieves a glyph from the store asynchronously.
         /// </summary>
-        /// <param name="fontName">The name of the font.</param>
+        /// <param name="fontName">The name of the font. Alternatively, a suffix of the name can be provided to search for the nearest font matching the given suffix.
+        /// This is used to look up a glyph in any font while requiring certain weight / italics specifications.</param>
         /// <param name="character">The character to retrieve.</param>
         /// <returns>The character glyph.</returns>
         Task<ITexturedCharacterGlyph?> GetAsync(string fontName, char character);

osu.Framework/Text/TextBuilder.cs

@@ -353,10 +353,15 @@ private bool tryCreateGlyph(char character, out TextBuilderGlyph glyph)
 
         private ITexturedCharacterGlyph? getTexturedGlyph(char character)
         {
-            return store.Get(font.FontName, character)
-                   ?? store.Get(string.Empty, character)
-                   ?? store.Get(font.FontName, fallbackCharacter)
-                   ?? store.Get(string.Empty, fallbackCharacter);
+            return tryGetGlyph(character, font, store) ??
+                   tryGetGlyph(fallbackCharacter, font, store);
+
+            static ITexturedCharacterGlyph? tryGetGlyph(char character, FontUsage font, ITexturedGlyphLookupStore store)
+            {
+                return store.Get(font.FontName, character)
+                       ?? store.Get(font.FontNameNoFamily, character)
+                       ?? store.Get(string.Empty, character);
+            }
         }
     }
 }