Expose resolved Font in layout and update documentation

src/SixLabors.Fonts/GlyphLayout.cs

@@ -13,6 +13,7 @@ internal readonly struct GlyphLayout
 {
     internal GlyphLayout(
         Glyph glyph,
+        Font font,
         Vector2 advanceOrigin,
         Vector2 glyphOrigin,
         Vector2 decorationOrigin,
@@ -25,6 +26,7 @@ internal GlyphLayout(
         int stringIndex)
     {
         this.Glyph = glyph;
+        this.Font = font;
         this.CodePoint = glyph.GlyphMetrics.CodePoint;
         this.AdvanceOrigin = advanceOrigin;
         this.GlyphOrigin = glyphOrigin;
@@ -43,6 +45,11 @@ internal GlyphLayout(
     /// </summary>
     public Glyph Glyph { get; }
 
+    /// <summary>
+    /// Gets the font used to shape and render this laid-out glyph entry.
+    /// </summary>
+    public Font Font { get; }
+
     /// <summary>
     /// Gets the code point represented by this glyph.
     /// </summary>

src/SixLabors.Fonts/GlyphLayoutData.cs

@@ -21,6 +21,7 @@ internal struct GlyphLayoutData
     /// Initializes a new instance of the <see cref="GlyphLayoutData"/> struct.
     /// </summary>
     /// <param name="metrics">The shaped glyph metrics for this codepoint.</param>
+    /// <param name="font">The font used to shape and render this entry.</param>
     /// <param name="pointSize">The point size at which the glyph is rendered.</param>
     /// <param name="scaledAdvance">The scaled advance of this entry.</param>
     /// <param name="scaledLineHeight">The scaled line height contributed by this entry.</param>
@@ -39,6 +40,7 @@ internal struct GlyphLayoutData
     /// <param name="hyphenationMarkerIndex">The marker index to use if this entry becomes a selected soft-hyphen break.</param>
     public GlyphLayoutData(
         IReadOnlyList<FontGlyphMetrics> metrics,
+        Font font,
         float pointSize,
         float scaledAdvance,
         float scaledLineHeight,
@@ -57,6 +59,7 @@ public GlyphLayoutData(
         int hyphenationMarkerIndex = NoHyphenationMarker)
     {
         this.Metrics = metrics;
+        this.Font = font;
         this.PointSize = pointSize;
         this.ScaledAdvance = scaledAdvance;
         this.ScaledLineHeight = scaledLineHeight;
@@ -81,6 +84,9 @@ public GlyphLayoutData(
     /// <summary>Gets the shaped glyph metrics produced for this codepoint (one codepoint may map to several glyphs).</summary>
     public IReadOnlyList<FontGlyphMetrics> Metrics { get; }
 
+    /// <summary>Gets the font used to shape and render this entry.</summary>
+    public Font Font { get; }
+
     /// <summary>Gets the point size at which this entry is rendered.</summary>
     public float PointSize { get; }
 

src/SixLabors.Fonts/GlyphMetrics.cs

@@ -17,20 +17,23 @@ public readonly struct GlyphMetrics
     /// <param name="advance">The positioned logical advance rectangle for the glyph entry in pixel units.</param>
     /// <param name="bounds">The rendered rectangle for the glyph entry in pixel units.</param>
     /// <param name="renderableBounds">The union of the positioned logical advance rectangle and rendered rectangle in pixel units.</param>
+    /// <param name="font">The font used to shape and render the glyph entry.</param>
     /// <param name="graphemeIndex">The grapheme index in the original text.</param>
     /// <param name="stringIndex">The UTF-16 index in the original text where the glyph entry begins.</param>
     internal GlyphMetrics(
         CodePoint codePoint,
         in FontRectangle advance,
         in FontRectangle bounds,
         in FontRectangle renderableBounds,
+        Font font,
         int graphemeIndex,
         int stringIndex)
     {
         this.CodePoint = codePoint;
         this.Advance = advance;
         this.Bounds = bounds;
         this.RenderableBounds = renderableBounds;
+        this.Font = font;
         this.GraphemeIndex = graphemeIndex;
         this.StringIndex = stringIndex;
     }
@@ -55,6 +58,11 @@ internal GlyphMetrics(
     /// </summary>
     public FontRectangle RenderableBounds { get; }
 
+    /// <summary>
+    /// Gets the font used to shape and render the glyph entry.
+    /// </summary>
+    public Font Font { get; }
+
     /// <summary>
     /// Gets the zero-based grapheme index in the original text.
     /// </summary>

src/SixLabors.Fonts/GlyphPositioningCollection.cs

@@ -236,7 +236,7 @@ public bool TryUpdate(Font font, GlyphSubstitutionCollection collection)
                             : new(0, 0, metrics.AdvanceWidth, 0);
 
                         // Track the number of inserted glyphs at the offset so we can correctly increment our position.
-                        this.glyphs.Insert(i += replacementCount, new(offset, new(shape, true) { Bounds = bounds }, pointSize, metrics.CloneForRendering(shape.TextRun)));
+                        this.glyphs.Insert(i += replacementCount, new(offset, new(shape, true) { Bounds = bounds }, font, pointSize, metrics.CloneForRendering(shape.TextRun)));
                         replacementCount++;
                     }
                 }
@@ -307,7 +307,7 @@ public bool TryAdd(Font font, GlyphSubstitutionCollection collection)
                     IsPositioned = true
                 };
 
-                this.glyphs.Add(new(offset, placeholderData, font.Size, placeholderMetrics));
+                this.glyphs.Add(new(offset, placeholderData, font, font.Size, placeholderMetrics));
                 continue;
             }
 
@@ -336,7 +336,7 @@ public bool TryAdd(Font font, GlyphSubstitutionCollection collection)
                 ? new(0, 0, 0, metrics.AdvanceHeight)
                 : new(0, 0, metrics.AdvanceWidth, 0);
 
-            this.glyphs.Add(new(offset, new(data, true) { Bounds = bounds }, font.Size, metrics.CloneForRendering(data.TextRun)));
+            this.glyphs.Add(new(offset, new(data, true) { Bounds = bounds }, font, font.Size, metrics.CloneForRendering(data.TextRun)));
         }
 
         return !hasFallBacks;
@@ -433,10 +433,11 @@ public bool ShouldProcess(FontMetrics fontMetrics, int index)
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     public class GlyphPositioningData
     {
-        public GlyphPositioningData(int offset, GlyphShapingData data, float pointSize, FontGlyphMetrics metrics)
+        public GlyphPositioningData(int offset, GlyphShapingData data, Font font, float pointSize, FontGlyphMetrics metrics)
         {
             this.Offset = offset;
             this.Data = data;
+            this.Font = font;
             this.PointSize = pointSize;
             this.Metrics = metrics;
         }
@@ -445,6 +446,8 @@ public GlyphPositioningData(int offset, GlyphShapingData data, float pointSize,
 
         public GlyphShapingData Data { get; set; }
 
+        public Font Font { get; set; }
+
         public float PointSize { get; set; }
 
         public FontGlyphMetrics Metrics { get; set; }

src/SixLabors.Fonts/GraphemeMetrics.cs

@@ -14,6 +14,7 @@ public readonly struct GraphemeMetrics
     /// <param name="advance">The positioned logical advance rectangle for the grapheme in pixel units.</param>
     /// <param name="bounds">The rendered glyph bounds for the grapheme in pixel units.</param>
     /// <param name="renderableBounds">The union of the positioned logical advance bounds and rendered glyph bounds in pixel units.</param>
+    /// <param name="font">The font used to shape and render the grapheme.</param>
     /// <param name="graphemeIndex">The grapheme index in the original text.</param>
     /// <param name="stringIndex">The UTF-16 index in the original text where the grapheme begins.</param>
     /// <param name="bidiLevel">The resolved bidi embedding level.</param>
@@ -22,6 +23,7 @@ internal GraphemeMetrics(
         FontRectangle advance,
         FontRectangle bounds,
         FontRectangle renderableBounds,
+        Font font,
         int graphemeIndex,
         int stringIndex,
         int bidiLevel,
@@ -30,6 +32,7 @@ internal GraphemeMetrics(
         this.Advance = advance;
         this.Bounds = bounds;
         this.RenderableBounds = renderableBounds;
+        this.Font = font;
         this.GraphemeIndex = graphemeIndex;
         this.StringIndex = stringIndex;
         this.BidiLevel = bidiLevel;
@@ -51,6 +54,11 @@ internal GraphemeMetrics(
     /// </summary>
     public FontRectangle RenderableBounds { get; }
 
+    /// <summary>
+    /// Gets the font used to shape and render the grapheme.
+    /// </summary>
+    public Font Font { get; }
+
     /// <summary>
     /// Gets the zero-based grapheme index in the original text.
     /// </summary>

src/SixLabors.Fonts/TextBlock.Visitors.cs

@@ -77,6 +77,7 @@ private struct GraphemeMetricsAccumulator
         private int stringIndex;
         private int bidiLevel;
         private bool isLineBreak;
+        private Font? font;
         private FontRectangle advanceBounds;
         private FontRectangle bounds;
         private bool hasCurrent;
@@ -95,6 +96,7 @@ public GraphemeMetricsAccumulator(GraphemeMetrics[] graphemes, float dpi)
             this.stringIndex = 0;
             this.bidiLevel = 0;
             this.isLineBreak = false;
+            this.font = null;
             this.advanceBounds = FontRectangle.Empty;
             this.bounds = FontRectangle.Empty;
             this.hasCurrent = false;
@@ -174,6 +176,7 @@ private void Start(
             this.stringIndex = glyph.StringIndex;
             this.bidiLevel = glyph.BidiLevel;
             this.isLineBreak = CodePoint.IsNewLine(glyph.CodePoint);
+            this.font = glyph.Font;
             this.advanceBounds = advanceBounds;
             this.bounds = bounds;
             this.hasCurrent = true;
@@ -197,6 +200,7 @@ private bool Flush(out GraphemeMetrics metrics)
                 this.advanceBounds,
                 this.bounds,
                 renderableBounds,
+                this.font!,
                 this.graphemeIndex,
                 this.stringIndex,
                 this.bidiLevel,
@@ -750,6 +754,7 @@ public void Visit(in GlyphLayout glyph)
                 advance,
                 bounds,
                 renderableBounds,
+                glyph.Font,
                 glyph.GraphemeIndex,
                 glyph.StringIndex);
 

src/SixLabors.Fonts/TextLayout.LineBreaking.cs

@@ -269,6 +269,8 @@ VerticalOrientationType.Rotate or
                     int graphemeCodePointMax = CodePoint.GetCodePointCount(grapheme) - 1;
 
                     // For non-decomposed glyphs the length is always 1.
+                    int glyphDataIndex = 0;
+
                     for (int i = 0; i < decomposedAdvances.Length; i++)
                     {
                         // Determine if this is the last codepoint in the grapheme.
@@ -277,7 +279,13 @@ VerticalOrientationType.Rotate or
                         float decomposedAdvance = decomposedAdvances[i];
 
                         // Work out the scaled metrics for the glyph.
-                        FontGlyphMetrics metric = metrics[i];
+                        while (glyphData[glyphDataIndex].Data.IsPlaceholder)
+                        {
+                            glyphDataIndex++;
+                        }
+
+                        GlyphPositioningCollection.GlyphPositioningData positionedGlyph = glyphData[glyphDataIndex];
+                        FontGlyphMetrics metric = positionedGlyph.Metrics;
 
                         // Adjust the advance for the last decomposed glyph to add tracking if applicable.
                         // Tracking should only be added once per grapheme, so only on the last codepoint of the grapheme.
@@ -357,12 +365,14 @@ VerticalOrientationType.Rotate or
                                 stringIndex,
                                 hyphenationMarkerCodePoint.Value,
                                 shapedText.LayoutMode,
+                                positionedGlyph.Font,
                                 options));
                         }
 
                         // Add our metrics to the line.
                         textLine.Add(
                             isDecomposed ? new FontGlyphMetrics[] { metric } : metrics,
+                            positionedGlyph.Font,
                             pointSize,
                             decomposedAdvance,
                             lineHeight,
@@ -380,6 +390,8 @@ VerticalOrientationType.Rotate or
                             mode,
                             options.LineSpacing,
                             hyphenationMarkerIndex);
+
+                        glyphDataIndex++;
                     }
 
                     codePointIndex++;
@@ -548,6 +560,7 @@ private static List<LineBreak> CollectLineBreaks(ReadOnlySpan<char> text, bool i
     /// <param name="stringIndex">The UTF-16 source index to map the marker to.</param>
     /// <param name="markerCodePoint">The marker codepoint to create.</param>
     /// <param name="layoutMode">The layout mode used to calculate marker orientation.</param>
+    /// <param name="font">The font used to shape and render the marker.</param>
     /// <param name="options">The text options used for layout.</param>
     /// <returns>The generated marker entry.</returns>
     internal static GlyphLayoutData CreateGeneratedMarker(
@@ -561,6 +574,7 @@ internal static GlyphLayoutData CreateGeneratedMarker(
         int stringIndex,
         CodePoint markerCodePoint,
         LayoutMode layoutMode,
+        Font font,
         TextOptions options)
     {
         anchorMetric.FontMetrics.TryGetGlyphId(markerCodePoint, out ushort markerGlyphId);
@@ -624,6 +638,7 @@ VerticalOrientationType.Rotate or
 
         return new GlyphLayoutData(
             new FontGlyphMetrics[] { markerMetric },
+            font,
             pointSize,
             markerAdvance,
             markerLineHeight * options.LineSpacing,

src/SixLabors.Fonts/TextLayout.cs

@@ -562,6 +562,7 @@ private static void LayoutLineHorizontal<TVisitor>(
                 visitor.Visit(
                     new GlyphLayout(
                     new Glyph(metric, data.PointSize),
+                    data.Font,
                     boundsLocation,
                     hardBreakGlyphOrigin,
                     penLocation,
@@ -590,6 +591,7 @@ private static void LayoutLineHorizontal<TVisitor>(
                 visitor.Visit(
                     new GlyphLayout(
                     new Glyph(metric, data.PointSize),
+                    data.Font,
                     boundsLocation,
                     glyphOrigin,
                     glyphOrigin,
@@ -770,6 +772,7 @@ private static void LayoutLineVertical<TVisitor>(
                 visitor.Visit(
                     new GlyphLayout(
                     new Glyph(metric, data.PointSize),
+                    data.Font,
                     boundsLocation,
                     hardBreakGlyphOrigin,
                     hardBreakDecorationOrigin,
@@ -924,6 +927,7 @@ private static void LayoutLineVertical<TVisitor>(
                 visitor.Visit(
                     new GlyphLayout(
                     new Glyph(metric, data.PointSize),
+                    data.Font,
                     boundsLocation,
                     glyphOrigin,
                     decorationOrigin,
@@ -1103,6 +1107,7 @@ private static void LayoutLineVerticalMixed<TVisitor>(
                 visitor.Visit(
                     new GlyphLayout(
                     new Glyph(metric, data.PointSize),
+                    data.Font,
                     boundsLocation,
                     hardBreakGlyphOrigin,
                     hardBreakDecorationOrigin,
@@ -1148,6 +1153,7 @@ private static void LayoutLineVerticalMixed<TVisitor>(
                     visitor.Visit(
                         new GlyphLayout(
                         new Glyph(metric, data.PointSize),
+                        data.Font,
                         boundsLocation,
                         glyphOrigin,
                         glyphOrigin,
@@ -1182,6 +1188,7 @@ private static void LayoutLineVerticalMixed<TVisitor>(
                     visitor.Visit(
                         new GlyphLayout(
                         new Glyph(metric, data.PointSize),
+                        data.Font,
                         boundsLocation,
                         glyphOrigin,
                         decorationOrigin,

src/SixLabors.Fonts/TextLine.cs

@@ -142,6 +142,7 @@ public int CountGlyphLayouts()
     /// Appends a shaped entry to this line, updating the aggregated line-level metrics.
     /// </summary>
     /// <param name="metrics">The glyph metrics produced by shaping this entry's codepoint.</param>
+    /// <param name="font">The font used to shape and render this entry.</param>
     /// <param name="pointSize">The point size at which the entry is rendered.</param>
     /// <param name="scaledAdvance">The scaled advance contributed by this entry.</param>
     /// <param name="scaledLineHeight">The scaled line height contributed by this entry (before line-spacing).</param>
@@ -161,6 +162,7 @@ public int CountGlyphLayouts()
     /// <param name="hyphenationMarkerIndex">The marker index to use if this entry becomes a selected soft-hyphen break.</param>
     public void Add(
         IReadOnlyList<FontGlyphMetrics> metrics,
+        Font font,
         float pointSize,
         float scaledAdvance,
         float scaledLineHeight,
@@ -224,6 +226,7 @@ public void Add(
 
         this.data.Add(new(
             metrics,
+            font,
             pointSize,
             scaledAdvance,
             scaledLineHeight,
@@ -300,6 +303,7 @@ public void AddPlaceholder(
         // but they do not consume source grapheme, codepoint, or UTF-16 indexes.
         this.Add(
             new FontGlyphMetrics[] { placeholderGlyph },
+            placeholder.Font,
             placeholder.PointSize,
             placeholderAdvance,
             placeholderLineHeight,
@@ -419,6 +423,7 @@ public void ApplyEllipsisMarker(
             anchor.StringIndex,
             markerCodePoint,
             options.LayoutMode,
+            anchor.Font,
             options);
 
         while (this.data.Count > 0 &&