Expose contiguous glyph indices span on ShapedBuffer

Consumers that need a ReadOnlySpan<ushort> of glyph IDs (the upcoming
GlyphTypeface.TryGetGlyphBounds batch path, SKFont.GetGlyphWidths, atlas
lookups...) previously had to allocate a parallel ushort[] and project
GlyphInfo.GlyphIndex into it. Carry that array on the ShapedBuffer instead:

- ShapedBuffer rents a parallel ushort[] from ArrayPool alongside the
  existing GlyphInfo[] rental, exposed as
  `public ReadOnlySpan<ushort> GlyphIndices`.
- The indexer setter syncs both, so HarfBuzz shaping and post-shape
  mutators (InterWordJustification rewrites the same GlyphIndex) keep
  the parallel view in lockstep with no caller change.
- Split / WithBidiLevel slice the indices alongside the GlyphInfos at
  the same offsets — both share the parent's pooled arrays.
- Dispose returns both rentals.

Consumer wiring:
- GlyphRunImpl: copies ShapedBuffer.GlyphIndices once via CopyTo when
  the source is a ShapedBuffer, dropping the per-glyph extract from the
  position loop.
- TextFormatterImpl.CreateEmptyTextLine: switched to the pooled public
  ctor + indexer (was passing a heap-allocated GlyphInfo[] to the
  internal slice ctor, which now requires a parallel ushort slice).

Tests cover indexer sync, overwrite, ascending split alignment,
empty-leading split, and dispose clearing the view.

Author: Gillibald

src/Avalonia.Base/Media/TextFormatting/ShapedBuffer.cs

@@ -55,7 +55,16 @@ public void Dispose()
         // Split children and WithBidiLevel aliases clone this ref so the array
         // survives until every observer has been disposed.
         private IRef<PooledArray<GlyphInfo>>? _glyphRef;
+
+        // Ref-counted handle to the pooled ushort[] that backs _glyphIndices. The
+        // parallel glyph-id array exists so consumers (GlyphRunImpl, the new
+        // TryGetGlyphBounds batch path, SKFont.GetGlyphWidths) can take a
+        // ReadOnlySpan<ushort> over the run's glyph IDs without walking the
+        // GlyphInfo struct array. Lifetime mirrors _glyphRef: cloned on Split /
+        // WithBidiLevel, disposed in Dispose, null on caller-owned storage.
+        private IRef<PooledArray<ushort>>? _glyphIndicesRef;
         private ArraySlice<GlyphInfo> _glyphInfos;
+        private ArraySlice<ushort> _glyphIndices;
 
         // Lazily-computed cluster-width cache. MeasureLength and metrics
         // queries both fold multi-glyph clusters and accumulate per-cluster
@@ -131,15 +140,18 @@ public ShapedBuffer(ReadOnlyMemory<char> text, int bufferLength, GlyphTypeface g
             Text = text;
             _glyphRef = RefCountable.Create(new PooledArray<GlyphInfo>(bufferLength));
             _glyphInfos = new ArraySlice<GlyphInfo>(_glyphRef.Item.Array, 0, bufferLength);
+            _glyphIndicesRef = RefCountable.Create(new PooledArray<ushort>(bufferLength));
+            _glyphIndices = new ArraySlice<ushort>(_glyphIndicesRef.Item.Array, 0, bufferLength);
             GlyphTypeface = glyphTypeface;
             FontRenderingEmSize = fontRenderingEmSize;
             BidiLevel = bidiLevel;
         }
 
-        internal ShapedBuffer(ReadOnlyMemory<char> text, ArraySlice<GlyphInfo> glyphInfos, GlyphTypeface glyphTypeface, double fontRenderingEmSize, sbyte bidiLevel)
+        internal ShapedBuffer(ReadOnlyMemory<char> text, ArraySlice<GlyphInfo> glyphInfos, ArraySlice<ushort> glyphIndices, GlyphTypeface glyphTypeface, double fontRenderingEmSize, sbyte bidiLevel)
         {
             Text = text;
             _glyphInfos = glyphInfos;
+            _glyphIndices = glyphIndices;
             GlyphTypeface = glyphTypeface;
             FontRenderingEmSize = fontRenderingEmSize;
             BidiLevel = bidiLevel;
@@ -152,19 +164,23 @@ internal ShapedBuffer(ReadOnlyMemory<char> text, ArraySlice<GlyphInfo> glyphInfo
         /// until every sibling has been disposed. When <paramref name="sourcePrefixRef"/>
         /// is null the alias starts without a cluster cache and will build its own lazily.
         /// </summary>
-        private ShapedBuffer(ReadOnlyMemory<char> text, ArraySlice<GlyphInfo> glyphInfos,
+        private ShapedBuffer(ReadOnlyMemory<char> text,
+            ArraySlice<GlyphInfo> glyphInfos, ArraySlice<ushort> glyphIndices,
             GlyphTypeface glyphTypeface, double fontRenderingEmSize, sbyte bidiLevel,
             IRef<PooledArray<GlyphInfo>>? sourceGlyphRef,
+            IRef<PooledArray<ushort>>? sourceGlyphIndicesRef,
             IRef<PooledArray<double>>? sourcePrefixRef,
             IRef<PooledArray<int>>? sourceStartsRef,
             int clusterStartIdx, int clusterCount, int sourceCacheGeneration)
         {
             Text = text;
             _glyphInfos = glyphInfos;
+            _glyphIndices = glyphIndices;
             GlyphTypeface = glyphTypeface;
             FontRenderingEmSize = fontRenderingEmSize;
             BidiLevel = bidiLevel;
             _glyphRef = sourceGlyphRef?.Clone();
+            _glyphIndicesRef = sourceGlyphIndicesRef?.Clone();
 
             if (sourcePrefixRef is not null)
             {
@@ -193,6 +209,16 @@ private ShapedBuffer(ReadOnlyMemory<char> text, ArraySlice<GlyphInfo> glyphInfos
         /// </summary>
         internal ArraySlice<GlyphInfo> GlyphInfos => _glyphInfos;
 
+        /// <summary>
+        /// Contiguous view of the glyph indices for this buffer, kept in sync with
+        /// <see cref="GlyphInfos"/> by the indexer setter. Consumers needing a
+        /// <see cref="ReadOnlySpan{T}"/> of glyph IDs (e.g. for
+        /// <c>GlyphTypeface.TryGetGlyphBounds</c> or
+        /// <c>SKFont.GetGlyphWidths</c>) can use this directly without allocating
+        /// a parallel array.
+        /// </summary>
+        public ReadOnlySpan<ushort> GlyphIndices => _glyphIndices.Span;
+
         /// <summary>
         /// The buffer's glyph typeface.
         /// </summary>
@@ -230,6 +256,10 @@ public void Dispose()
             _glyphRef = null;
             _glyphInfos = ArraySlice<GlyphInfo>.Empty; // ensure we don't misuse a returned array
 
+            _glyphIndicesRef?.Dispose();
+            _glyphIndicesRef = null;
+            _glyphIndices = ArraySlice<ushort>.Empty;
+
             ReleaseClusterCacheRefs();
             _clusterPrefix = null;
             _clusterStartChars = null;
@@ -259,6 +289,7 @@ public GlyphInfo this[int index]
             set
             {
                 _glyphInfos[index] = value;
+                _glyphIndices[index] = value.GlyphIndex;
                 // Bump the shared glyph generation so any sibling that built a
                 // cluster cache against the pre-mutation glyphs will detect the
                 // mismatch on its next EnsureClusterCache call and rebuild.
@@ -558,8 +589,8 @@ internal ShapedBuffer WithBidiLevel(sbyte paragraphEmbeddingLevel)
             }
 
             return new ShapedBuffer(
-                Text, _glyphInfos, GlyphTypeface, FontRenderingEmSize, paragraphEmbeddingLevel,
-                _glyphRef, prefixRef, startsRef, startIdx, count, _cacheGeneration);
+                Text, _glyphInfos, _glyphIndices, GlyphTypeface, FontRenderingEmSize, paragraphEmbeddingLevel,
+                _glyphRef, _glyphIndicesRef, prefixRef, startsRef, startIdx, count, _cacheGeneration);
         }
 
         /// <summary>
@@ -576,7 +607,15 @@ internal ShapedBuffer CloneWritable()
 
             span.CopyTo(glyphs);
 
-            return new ShapedBuffer(Text, new ArraySlice<GlyphInfo>(glyphs), GlyphTypeface, FontRenderingEmSize, BidiLevel);
+            // The glyph indices ride in their own slice and must stay aligned with the
+            // copied infos; justification mutates advances only, so a plain copy holds.
+            var indicesSpan = _glyphIndices.Span;
+            var indices = new ushort[indicesSpan.Length];
+
+            indicesSpan.CopyTo(indices);
+
+            return new ShapedBuffer(Text, new ArraySlice<GlyphInfo>(glyphs), new ArraySlice<ushort>(indices),
+                GlyphTypeface, FontRenderingEmSize, BidiLevel);
         }
 
         int IReadOnlyCollection<GlyphInfo>.Count => _glyphInfos.Length;
@@ -596,7 +635,9 @@ public SplitResult<ShapedBuffer> Split(int textLength)
             if (textLength <= 0)
             {
                 var emptyBuffer = new ShapedBuffer(
-                    Text.Slice(0, 0), _glyphInfos.Slice(_glyphInfos.Start, 0),
+                    Text.Slice(0, 0),
+                    _glyphInfos.Slice(_glyphInfos.Start, 0),
+                    _glyphIndices.Slice(_glyphIndices.Start, 0),
                     GlyphTypeface, FontRenderingEmSize, BidiLevel);
 
                 return new SplitResult<ShapedBuffer>(emptyBuffer, this);
@@ -662,6 +703,8 @@ private SplitResult<ShapedBuffer> SplitAscending(int textLength)
 
             var firstGlyphs = _glyphInfos.Slice(sliceStart, splitGlyphIndex);
             var secondGlyphs = _glyphInfos.Slice(sliceStart + splitGlyphIndex, glyphInfosLength - splitGlyphIndex);
+            var firstGlyphIndices = _glyphIndices.Slice(sliceStart, splitGlyphIndex);
+            var secondGlyphIndices = _glyphIndices.Slice(sliceStart + splitGlyphIndex, glyphInfosLength - splitGlyphIndex);
 
             var firstText = Text.Slice(0, splitCharCount);
             var secondText = Text.Slice(splitCharCount);
@@ -672,9 +715,9 @@ private SplitResult<ShapedBuffer> SplitAscending(int textLength)
             var leadingClusterCount = FindClusterOffsetForSplit(splitCharCount);
 
             var leading = new ShapedBuffer(
-                firstText, firstGlyphs,
+                firstText, firstGlyphs, firstGlyphIndices,
                 GlyphTypeface, FontRenderingEmSize, BidiLevel,
-                _glyphRef, _prefixRef, _startsRef,
+                _glyphRef, _glyphIndicesRef, _prefixRef, _startsRef,
                 _clusterStartIdx, leadingClusterCount, _cacheGeneration);
 
             if (secondText.Length == 0)
@@ -683,9 +726,9 @@ private SplitResult<ShapedBuffer> SplitAscending(int textLength)
             }
 
             var trailing = new ShapedBuffer(
-                secondText, secondGlyphs,
+                secondText, secondGlyphs, secondGlyphIndices,
                 GlyphTypeface, FontRenderingEmSize, BidiLevel,
-                _glyphRef, _prefixRef, _startsRef,
+                _glyphRef, _glyphIndicesRef, _prefixRef, _startsRef,
                 _clusterStartIdx + leadingClusterCount, _clusterCount - leadingClusterCount, _cacheGeneration);
 
             return new SplitResult<ShapedBuffer>(leading, trailing);
@@ -735,6 +778,8 @@ private SplitResult<ShapedBuffer> SplitDescending(int textLength)
             // Visual trailing = glyphs [splitGlyphIndex, end) → logically text[0..textLength] (our "first")
             var secondGlyphs = _glyphInfos.Slice(sliceStart, splitGlyphIndex);
             var firstGlyphs = _glyphInfos.Slice(sliceStart + splitGlyphIndex, glyphInfosLength - splitGlyphIndex);
+            var secondGlyphIndices = _glyphIndices.Slice(sliceStart, splitGlyphIndex);
+            var firstGlyphIndices = _glyphIndices.Slice(sliceStart + splitGlyphIndex, glyphInfosLength - splitGlyphIndex);
 
             var firstText = Text.Slice(0, textLength);
             var secondText = Text.Slice(textLength);
@@ -747,9 +792,9 @@ private SplitResult<ShapedBuffer> SplitDescending(int textLength)
             var firstClusterCount = FindClusterOffsetForSplit(textLength);
 
             var first = new ShapedBuffer(
-                firstText, firstGlyphs,
+                firstText, firstGlyphs, firstGlyphIndices,
                 GlyphTypeface, FontRenderingEmSize, BidiLevel,
-                _glyphRef, _prefixRef, _startsRef,
+                _glyphRef, _glyphIndicesRef, _prefixRef, _startsRef,
                 _clusterStartIdx, firstClusterCount, _cacheGeneration);
 
             if (secondText.Length == 0 || secondGlyphs.Length == 0)
@@ -758,9 +803,9 @@ private SplitResult<ShapedBuffer> SplitDescending(int textLength)
             }
 
             var second = new ShapedBuffer(
-                secondText, secondGlyphs,
+                secondText, secondGlyphs, secondGlyphIndices,
                 GlyphTypeface, FontRenderingEmSize, BidiLevel,
-                _glyphRef, _prefixRef, _startsRef,
+                _glyphRef, _glyphIndicesRef, _prefixRef, _startsRef,
                 _clusterStartIdx + firstClusterCount, _clusterCount - firstClusterCount, _cacheGeneration);
 
             return new SplitResult<ShapedBuffer>(first, second);

src/Avalonia.Base/Media/TextFormatting/TextFormatterImpl.cs

@@ -843,10 +843,10 @@ public static TextLineImpl CreateEmptyTextLine(int firstTextSourceIndex, double
             var properties = paragraphProperties.DefaultTextRunProperties;
             var glyphTypeface = properties.CachedGlyphTypeface;
             var glyph = glyphTypeface.CharacterToGlyphMap[s_empty[0]];
-            var glyphInfos = new[] { new GlyphInfo(glyph, firstTextSourceIndex, 0.0) };
 
-            var shapedBuffer = new ShapedBuffer(s_empty.AsMemory(), glyphInfos, glyphTypeface, properties.FontRenderingEmSize,
-                (sbyte)flowDirection);
+            var shapedBuffer = new ShapedBuffer(s_empty.AsMemory(), 1, glyphTypeface,
+                properties.FontRenderingEmSize, (sbyte)flowDirection);
+            shapedBuffer[0] = new GlyphInfo(glyph, firstTextSourceIndex, 0.0);
 
             var textRuns = new TextRun[] { new ShapedTextRun(shapedBuffer, properties) };
 

src/Skia/Avalonia.Skia/GlyphRunImpl.cs

@@ -38,14 +38,25 @@ public GlyphRunImpl(GlyphTypeface glyphTypeface, double fontRenderingEmSize,
             _glyphIndices = new ushort[count];
             _glyphPositions = new SKPoint[count];
 
-            // GetGlyphWidths needs _glyphIndices populated before the
-            // per-glyph bounds can be fetched, so this walk has to come
-            // first. It deliberately does no other work — positions and
-            // runBounds are built together in the fused walk below, using
-            // a single currentX accumulator.
-            for (int i = 0; i < count; i++)
+            // GetGlyphWidths needs _glyphIndices populated before the per-glyph
+            // bounds can be fetched, so this walk has to come first. It does no
+            // other work — positions and runBounds are built together in the
+            // fused walk below, using a single currentX accumulator.
+            //
+            // ShapedBuffer maintains a contiguous ushort span over the run's
+            // glyph IDs; copy it once instead of walking per glyph. Falls back
+            // to per-glyph when the caller constructed a GlyphRun directly from
+            // raw GlyphInfo records (custom rendering, glyph palettes).
+            if (glyphInfos is Media.TextFormatting.ShapedBuffer shapedBuffer)
             {
-                _glyphIndices[i] = glyphInfos[i].GlyphIndex;
+                shapedBuffer.GlyphIndices.CopyTo(_glyphIndices);
+            }
+            else
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    _glyphIndices[i] = glyphInfos[i].GlyphIndex;
+                }
             }
 
             // Ideally the requested edging should be passed to the glyph run.

tests/Avalonia.Base.UnitTests/Media/TextFormatting/ShapedBufferTests.cs

@@ -0,0 +1,140 @@
+using System;
+using Avalonia.Base.UnitTests.Media.Fonts.Tables;
+using Avalonia.Media;
+using Avalonia.Media.TextFormatting;
+using Avalonia.Platform;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Media.TextFormatting;
+
+public class ShapedBufferTests
+{
+    private const string InterFontUri =
+        "resm:Avalonia.Base.UnitTests.Assets.Inter-Regular.ttf?assembly=Avalonia.Base.UnitTests";
+
+    private static GlyphTypeface LoadInter()
+    {
+        var assetLoader = new StandardAssetLoader();
+        using var stream = assetLoader.Open(new Uri(InterFontUri));
+        return new GlyphTypeface(new CustomPlatformTypeface(stream));
+    }
+
+    [Fact]
+    public void GlyphIndices_Length_Matches_BufferLength()
+    {
+        var typeface = LoadInter();
+
+        using var buffer = new ShapedBuffer("hello".AsMemory(), 5, typeface, 16, 0);
+
+        Assert.Equal(5, buffer.GlyphIndices.Length);
+        Assert.Equal(5, buffer.Length);
+    }
+
+    [Fact]
+    public void Indexer_Set_Syncs_GlyphIndices()
+    {
+        var typeface = LoadInter();
+
+        using var buffer = new ShapedBuffer("ABC".AsMemory(), 3, typeface, 16, 0);
+
+        buffer[0] = new GlyphInfo(42, 0, 10);
+        buffer[1] = new GlyphInfo(99, 1, 11);
+        buffer[2] = new GlyphInfo(7,  2, 12);
+
+        Assert.Equal(42, buffer.GlyphIndices[0]);
+        Assert.Equal(99, buffer.GlyphIndices[1]);
+        Assert.Equal(7,  buffer.GlyphIndices[2]);
+
+        // And the GlyphInfo accessor still works.
+        Assert.Equal(42, buffer[0].GlyphIndex);
+        Assert.Equal(99, buffer[1].GlyphIndex);
+        Assert.Equal(7,  buffer[2].GlyphIndex);
+    }
+
+    [Fact]
+    public void Indexer_Set_Overwrite_Updates_GlyphIndices()
+    {
+        var typeface = LoadInter();
+
+        using var buffer = new ShapedBuffer("X".AsMemory(), 1, typeface, 16, 0);
+
+        buffer[0] = new GlyphInfo(10, 0, 1);
+        Assert.Equal(10, buffer.GlyphIndices[0]);
+
+        // Mutating the entry (as InterWordJustification does) keeps the parallel array in sync.
+        buffer[0] = new GlyphInfo(10, 0, 2);
+        Assert.Equal(10, buffer.GlyphIndices[0]);
+
+        buffer[0] = new GlyphInfo(33, 0, 1);
+        Assert.Equal(33, buffer.GlyphIndices[0]);
+    }
+
+    [Fact]
+    public void Split_Ascending_Preserves_GlyphIndices_Alignment()
+    {
+        var typeface = LoadInter();
+
+        // LTR (bidi 0): clusters ascending. Five 1-char clusters.
+        using var buffer = new ShapedBuffer("ABCDE".AsMemory(), 5, typeface, 16, 0);
+        buffer[0] = new GlyphInfo(10, 0, 5);
+        buffer[1] = new GlyphInfo(20, 1, 5);
+        buffer[2] = new GlyphInfo(30, 2, 5);
+        buffer[3] = new GlyphInfo(40, 3, 5);
+        buffer[4] = new GlyphInfo(50, 4, 5);
+
+        var split = buffer.Split(2);
+
+        Assert.NotNull(split.First);
+        Assert.NotNull(split.Second);
+        Assert.Equal(2, split.First!.GlyphIndices.Length);
+        Assert.Equal(3, split.Second!.GlyphIndices.Length);
+
+        Assert.Equal(10, split.First.GlyphIndices[0]);
+        Assert.Equal(20, split.First.GlyphIndices[1]);
+
+        Assert.Equal(30, split.Second.GlyphIndices[0]);
+        Assert.Equal(40, split.Second.GlyphIndices[1]);
+        Assert.Equal(50, split.Second.GlyphIndices[2]);
+
+        // Both halves stay in lockstep with the GlyphInfo indexer.
+        Assert.Equal(split.First[0].GlyphIndex,  split.First.GlyphIndices[0]);
+        Assert.Equal(split.Second[1].GlyphIndex, split.Second.GlyphIndices[1]);
+    }
+
+    [Fact]
+    public void Split_At_Zero_Yields_Empty_Leading_With_Empty_Indices()
+    {
+        var typeface = LoadInter();
+
+        using var buffer = new ShapedBuffer("ABC".AsMemory(), 3, typeface, 16, 0);
+        buffer[0] = new GlyphInfo(10, 0, 5);
+        buffer[1] = new GlyphInfo(20, 1, 5);
+        buffer[2] = new GlyphInfo(30, 2, 5);
+
+        var split = buffer.Split(0);
+
+        Assert.NotNull(split.First);
+        Assert.Equal(0, split.First!.GlyphIndices.Length);
+        Assert.Equal(0, split.First.Length);
+        Assert.NotNull(split.Second);
+        Assert.Equal(3, split.Second!.GlyphIndices.Length);
+    }
+
+    [Fact]
+    public void Dispose_Clears_GlyphIndices_View()
+    {
+        var typeface = LoadInter();
+
+        var buffer = new ShapedBuffer("AB".AsMemory(), 2, typeface, 16, 0);
+        buffer[0] = new GlyphInfo(1, 0, 1);
+        buffer[1] = new GlyphInfo(2, 1, 1);
+
+        Assert.Equal(2, buffer.GlyphIndices.Length);
+
+        buffer.Dispose();
+
+        // After dispose the views are reset so we don't reach into the returned pool buffer.
+        Assert.Equal(0, buffer.GlyphIndices.Length);
+        Assert.Equal(0, buffer.Length);
+    }
+}