Add vertical glyph advance API to GlyphTypeface

Mirror the existing TryGetHorizontalGlyphAdvance / ...Advances pair with
vertical equivalents. Until now a vertical-layout caller (CJK, Mongolian)
had no advance-only path on GlyphTypeface and had to go through
TryGetGlyphMetrics, which after PR2b reads the glyf bounding box per
glyph — pure waste when only the advance is needed.

VerticalMetricsTable already exposes the per-glyph and batch readers
internally (used by TryGetGlyphMetrics(batch)); this is a thin wrapper
over them.

Tests cover the Latin (no vmtx → false) and CJK (vmtx → positive
advances) cases and batch/single parity using Inter and MiSans-Normal.

Audit note: HorizontalMetricsTable and VerticalMetricsTable batch readers
already span-cache (each fetches _data.Span once per call, reusing a
BigEndianBinaryReader across glyphs). No metrics-table refactor is
needed — the speculative Part 2 of the plan collapses to nothing.

Author: Gillibald

src/Avalonia.Base/Media/GlyphTypeface.cs

@@ -713,6 +713,53 @@ public bool TryGetHorizontalGlyphAdvances(ReadOnlySpan<ushort> glyphIndices, Spa
             return _hmTable.TryGetAdvances(glyphIndices, advances);
         }
 
+        /// <summary>
+        /// Attempts to retrieve the vertical advance height for the specified glyph.
+        /// </summary>
+        /// <remarks>Returns false if vertical metrics are not available (the font has no
+        /// <c>vmtx</c> table — the common case for Latin fonts) or if the specified glyph
+        /// is not present in the metrics table.</remarks>
+        /// <param name="glyphIndex">The identifier of the glyph for which to obtain the vertical advance height.</param>
+        /// <param name="advance">When this method returns, contains the vertical advance height of the glyph if found; otherwise, zero. This
+        /// parameter is passed uninitialized.</param>
+        /// <returns>true if the vertical advance height was successfully retrieved; otherwise, false.</returns>
+        public bool TryGetVerticalGlyphAdvance(ushort glyphIndex, out ushort advance)
+        {
+            advance = default;
+
+            if (!_hasVerticalMetrics || _vmTable is null)
+            {
+                return false;
+            }
+
+            if (!_vmTable.TryGetAdvance(glyphIndex, out advance))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Attempts to retrieve vertical advance heights for multiple glyphs in a single operation.
+        /// </summary>
+        /// <remarks>This method is significantly more efficient than calling <see cref="TryGetVerticalGlyphAdvance"/>
+        /// multiple times as it minimizes memory access overhead and exploits data locality. This is the preferred method
+        /// for batch vertical-layout scenarios (CJK, Mongolian). Returns false if vertical metrics
+        /// are not available.</remarks>
+        /// <param name="glyphIndices">Read-only span of glyph identifiers for which to retrieve advance heights.</param>
+        /// <param name="advances">Output span to write the advance heights. Must be at least as long as <paramref name="glyphIndices"/>.</param>
+        /// <returns>true if vertical metrics are available and all advances were successfully retrieved; otherwise, false.</returns>
+        public bool TryGetVerticalGlyphAdvances(ReadOnlySpan<ushort> glyphIndices, Span<ushort> advances)
+        {
+            if (!_hasVerticalMetrics || _vmTable is null)
+            {
+                return false;
+            }
+
+            return _vmTable.TryGetAdvances(glyphIndices, advances);
+        }
+
         /// <summary>
         /// Attempts to retrieve the metrics for the specified glyph.
         /// </summary>

tests/Avalonia.Base.UnitTests/Media/GlyphTypefaceTests.cs

@@ -16,6 +16,7 @@ public class GlyphTypefaceTests
         private const string InterFontUri = "resm:Avalonia.Base.UnitTests.Assets.Inter-Regular.ttf?assembly=Avalonia.Base.UnitTests";
         private const string BlankFontUri = "resm:Avalonia.Base.UnitTests.Assets.AdobeBlank2VF.ttf?assembly=Avalonia.Base.UnitTests";
         private const string GB18030FontUri = "resm:Avalonia.Base.UnitTests.Assets.NISC18030.ttf?assembly=Avalonia.Base.UnitTests";
+        private const string MiSansFontUri = "resm:Avalonia.Base.UnitTests.Assets.MiSans-Normal.ttf?assembly=Avalonia.Base.UnitTests";
 
         [Fact]
         public void Should_Load_Inter_Font()
@@ -342,6 +343,69 @@ public void TryGetGlyphMetrics_Batch_Matches_Single()
             }
         }
 
+        [Fact]
+        public void TryGetVerticalGlyphAdvance_Returns_False_For_Latin_Font()
+        {
+            var assetLoader = new StandardAssetLoader();
+            using var stream = assetLoader.Open(new Uri(InterFontUri));
+            var typeface = new GlyphTypeface(new CustomPlatformTypeface(stream));
+
+            var glyphIndex = typeface.CharacterToGlyphMap['A'];
+
+            // Latin fonts typically carry no vmtx table — the call returns false and
+            // leaves the advance at zero.
+            Assert.False(typeface.TryGetVerticalGlyphAdvance(glyphIndex, out var advance));
+            Assert.Equal((ushort)0, advance);
+        }
+
+        [Fact]
+        public void TryGetVerticalGlyphAdvances_Batch_Returns_False_For_Latin_Font()
+        {
+            var assetLoader = new StandardAssetLoader();
+            using var stream = assetLoader.Open(new Uri(InterFontUri));
+            var typeface = new GlyphTypeface(new CustomPlatformTypeface(stream));
+
+            var map = typeface.CharacterToGlyphMap;
+            var glyphIndices = new ushort[] { map['A'], map['B'], map['g'] };
+            var advances = new ushort[glyphIndices.Length];
+
+            Assert.False(typeface.TryGetVerticalGlyphAdvances(glyphIndices, advances));
+        }
+
+        [Fact]
+        public void TryGetVerticalGlyphAdvance_Returns_True_For_CJK_Font()
+        {
+            var assetLoader = new StandardAssetLoader();
+            using var stream = assetLoader.Open(new Uri(MiSansFontUri));
+            var typeface = new GlyphTypeface(new CustomPlatformTypeface(stream));
+
+            // CJK glyph: U+4E2D ("中"). MiSans is a CJK font with a vmtx table.
+            var glyphIndex = typeface.CharacterToGlyphMap['中'];
+
+            Assert.True(typeface.TryGetVerticalGlyphAdvance(glyphIndex, out var advance));
+            Assert.True(advance > 0, "Expected a positive vertical advance for a CJK glyph.");
+        }
+
+        [Fact]
+        public void TryGetVerticalGlyphAdvances_Batch_Matches_Single_For_CJK_Font()
+        {
+            var assetLoader = new StandardAssetLoader();
+            using var stream = assetLoader.Open(new Uri(MiSansFontUri));
+            var typeface = new GlyphTypeface(new CustomPlatformTypeface(stream));
+
+            var map = typeface.CharacterToGlyphMap;
+            var glyphIndices = new ushort[] { map['中'], map['文'], map['字'], map[' '] };
+
+            var batch = new ushort[glyphIndices.Length];
+            Assert.True(typeface.TryGetVerticalGlyphAdvances(glyphIndices, batch));
+
+            for (var i = 0; i < glyphIndices.Length; i++)
+            {
+                Assert.True(typeface.TryGetVerticalGlyphAdvance(glyphIndices[i], out var single));
+                Assert.Equal(single, batch[i]);
+            }
+        }
+
         [Fact]
         public void Should_Have_Valid_PlatformTypeface()
         {