Fix multiline rendering

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor{TPixel}.cs

@@ -66,8 +66,8 @@ void Draw(IEnumerable<DrawingOperation> operations)
                              this.SourceRectangle);
 
                     Buffer2D<float> buffer = operation.Map;
-                    int startY = operation.Location.Y;
-                    int startX = operation.Location.X;
+                    int startY = operation.RenderLocation.Y;
+                    int startX = operation.RenderLocation.X;
                     int offsetSpan = 0;
 
                     if (startX + buffer.Height < 0)

src/ImageSharp.Drawing/Processing/Processors/Text/DrawingOperation.cs

@@ -13,7 +13,7 @@ internal struct DrawingOperation
 
         public byte RenderPass { get; set; }
 
-        public Point Location { get; set; }
+        public Point RenderLocation { get; set; }
 
         public Brush Brush { get; internal set; }
     }

src/ImageSharp.Drawing/Processing/Processors/Text/RichTextGlyphRenderer.cs

@@ -48,17 +48,18 @@ internal sealed class RichTextGlyphRenderer : BaseGlyphBuilder, IColorGlyphRende
         // - Provide a good accuracy (smaller than 0.2% image difference compared to the non-caching variant)
         // - Cache hit ratio above 60%
         private const float AccuracyMultiple = 8;
-        private readonly Dictionary<(GlyphRendererParameters Glyph, PointF SubPixelOffset), GlyphRenderData> glyphData = new();
+        private readonly Dictionary<(GlyphRendererParameters Glyph, RectangleF Bounds), GlyphRenderData> glyphData = new();
         private bool rasterizationRequired;
         private readonly bool noCache;
-        private (GlyphRendererParameters Glyph, PointF SubPixelOffset) currentCacheKey;
+        private (GlyphRendererParameters Glyph, RectangleF Bounds) currentCacheKey;
 
         public RichTextGlyphRenderer(
             RichTextOptions textOptions,
             DrawingOptions drawingOptions,
             MemoryAllocator memoryAllocator,
             Pen pen,
             Brush brush)
+            : base(drawingOptions.Transform)
         {
             this.textOptions = textOptions;
             this.drawingOptions = drawingOptions;
@@ -67,9 +68,6 @@ public RichTextGlyphRenderer(
             this.defaultBrush = brush;
             this.DrawingOperations = new List<DrawingOperation>();
 
-            // Set the default transform.
-            this.Builder.SetTransform(drawingOptions.Transform);
-
             IPath path = textOptions.Path;
             if (path is not null)
             {
@@ -138,15 +136,17 @@ protected override void BeginGlyph(in FontRectangle bounds, in GlyphRendererPara
             if (!this.noCache)
             {
                 // Create a cache entry for the glyph.
+                // We need to apply the default transform to the bounds to get the correct size
+                // for comparison with future glyphs. We can use this cached glyph anywhere in the text block.
                 var currentBounds = RectangleF.Transform(
-                        new RectangleF(bounds.Location, new(bounds.Width, bounds.Height)),
-                        this.drawingOptions.Transform);
+                       new RectangleF(bounds.Location, new(bounds.Width, bounds.Height)),
+                       this.drawingOptions.Transform);
 
-                PointF subPixelOffset = currentBounds.Location - ClampToPixel(currentBounds.Location);
-                subPixelOffset.X = MathF.Round(subPixelOffset.X * AccuracyMultiple) / AccuracyMultiple;
-                subPixelOffset.Y = MathF.Round(subPixelOffset.Y * AccuracyMultiple) / AccuracyMultiple;
+                SizeF subPixelSize = new(
+                    MathF.Round(currentBounds.Width * AccuracyMultiple) / AccuracyMultiple,
+                    MathF.Round(currentBounds.Height * AccuracyMultiple) / AccuracyMultiple);
 
-                this.currentCacheKey = (parameters, subPixelOffset);
+                this.currentCacheKey = (parameters, new RectangleF(new(0, 0), subPixelSize));
                 if (this.glyphData.ContainsKey(this.currentCacheKey))
                 {
                     // We have already drawn the glyph vectors.
@@ -155,6 +155,8 @@ protected override void BeginGlyph(in FontRectangle bounds, in GlyphRendererPara
                 }
             }
 
+            // Transform the glyph vectors using the original bounds
+            // The default transform will automatically be applied.
             this.TransformGlyph(in bounds);
             this.rasterizationRequired = true;
         }
@@ -273,7 +275,7 @@ protected override void EndGlyph()
             GlyphRenderData renderData = default;
 
             // Fix up the text runs colors.
-            // Only if both brush and pen is null do we fallback to the defualt value
+            // Only if both brush and pen is null do we fallback to the default value.
             if (this.currentBrush == null && this.currentPen == null)
             {
                 this.currentBrush = this.defaultBrush;
@@ -284,8 +286,8 @@ protected override void EndGlyph()
             bool renderOutline = false;
 
             // If we are using the fonts color layers we ignore the request to draw an outline only
-            // cause that wont really work and instead force drawing with fill with the requested color
-            // if color fonts disabled then this.currentColor will always be null
+            // because that won't really work. Instead we force drawing using fill with the requested color.
+            // If color fonts are disabled then this.currentColor will always be null.
             if (this.currentBrush != null || this.currentColor != null)
             {
                 renderFill = true;
@@ -310,16 +312,14 @@ protected override void EndGlyph()
 
             // Path has already been added to the collection via the base class.
             IPath path = this.Paths.Last();
+            Point renderLocation = ClampToPixel(path.Bounds.Location);
             if (this.noCache || this.rasterizationRequired)
             {
                 if (path.Bounds.Equals(RectangleF.Empty))
                 {
                     return;
                 }
 
-                // If we are using the fonts color layers we ignore the request to draw an outline only
-                // cause that wont really work and instead force drawing with fill with the requested color
-                // if color fonts disabled then this.currentColor will always be null
                 if (renderFill)
                 {
                     renderData.FillMap = this.Render(path);
@@ -331,6 +331,10 @@ protected override void EndGlyph()
                     renderData.OutlineMap = this.Render(path);
                 }
 
+                // Capture the delta between the location and the truncated render location.
+                // We can use this to offset the render location on the next instance of this glyph.
+                renderData.LocationDelta = (Vector2)(path.Bounds.Location - renderLocation);
+
                 if (!this.noCache)
                 {
                     this.glyphData[this.currentCacheKey] = renderData;
@@ -339,13 +343,16 @@ protected override void EndGlyph()
             else
             {
                 renderData = this.glyphData[this.currentCacheKey];
+
+                // Offset the render location by the delta from the cached glyph and this one.
+                renderLocation = (Point)(path.Bounds.Location - (PointF)renderData.LocationDelta);
             }
 
             if (renderData.FillMap != null)
             {
                 this.DrawingOperations.Add(new DrawingOperation
                 {
-                    Location = ClampToPixel(path.Bounds.Location),
+                    RenderLocation = renderLocation,
                     Map = renderData.FillMap,
                     Brush = this.currentBrush,
                     RenderPass = RenderOrderFill
@@ -356,7 +363,7 @@ protected override void EndGlyph()
             {
                 this.DrawingOperations.Add(new DrawingOperation
                 {
-                    Location = ClampToPixel(path.Bounds.Location),
+                    RenderLocation = renderLocation,
                     Map = renderData.OutlineMap,
                     Brush = this.currentPen?.StrokeFill ?? this.currentBrush,
                     RenderPass = RenderOrderOutline
@@ -375,9 +382,9 @@ protected override void EndText()
         public void Dispose() => this.Dispose(true);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Point ClampToPixel(PointF point)
-            => Point.Truncate(point);
+        private static Point ClampToPixel(PointF point) => Point.Truncate(point);
 
+        // Point.Truncate(point);
         private void FinalizeDecoration(ref TextDecorationDetails? decoration)
         {
             if (decoration != null)
@@ -396,11 +403,11 @@ private void FinalizeDecoration(ref TextDecorationDetails? decoration)
 
                 if (outline.Bounds.Width != 0 && outline.Bounds.Height != 0)
                 {
-                    // Render the Path here
+                    // Render the path here. Decorations are uncached.
                     this.DrawingOperations.Add(new DrawingOperation
                     {
                         Brush = decoration.Value.Pen.StrokeFill,
-                        Location = ClampToPixel(outline.Bounds.Location),
+                        RenderLocation = ClampToPixel(outline.Bounds.Location),
                         Map = this.Render(outline),
                         RenderPass = RenderOrderDecoration
                     });
@@ -444,14 +451,7 @@ private void AppendDecoration(ref TextDecorationDetails? decoration, Vector2 sta
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void TransformGlyph(in FontRectangle bounds)
-        {
-            if (this.path is null)
-            {
-                return;
-            }
-
-            this.Builder.SetTransform(this.ComputeTransform(in bounds));
-        }
+            => this.Builder.SetTransform(this.ComputeTransform(in bounds));
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private Matrix3x2 ComputeTransform(in FontRectangle bounds)
@@ -482,15 +482,19 @@ private Matrix3x2 ComputeTransform(in FontRectangle bounds)
 
         private Buffer2D<float> Render(IPath path)
         {
-            // We need to offset the path now against 0,0 for rasterization.
-            IPath offsetPath = path.Translate(-path.Bounds.Location);
+            // We need to offset the path now against the equivalent pixel position of [0,0] for rasterization.
+            IPath offsetPath = path.Translate(-ClampToPixel(path.Bounds.Location));
             Size size = Rectangle.Ceiling(offsetPath.Bounds).Size;
+
+            // Pad to prevent edge clipping.
+            size += new Size(2, 2);
+
             int subpixelCount = FillPathProcessor.MinimumSubpixelCount;
             float xOffset = .5F;
             GraphicsOptions graphicsOptions = this.drawingOptions.GraphicsOptions;
             if (graphicsOptions.Antialias)
             {
-                xOffset = 0F; // We are antialiasing skip offsetting as real antialiasing should take care of offset.
+                xOffset = 0F; // We are antialiasing. Skip offsetting as real antialiasing should take care of offset.
                 subpixelCount = Math.Max(subpixelCount, graphicsOptions.AntialiasSubpixelDepth);
             }
 
@@ -543,7 +547,7 @@ private void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    foreach (KeyValuePair<(GlyphRendererParameters Glyph, PointF SubPixelOffset), GlyphRenderData> kv in this.glyphData)
+                    foreach (KeyValuePair<(GlyphRendererParameters Glyph, RectangleF Bounds), GlyphRenderData> kv in this.glyphData)
                     {
                         kv.Value.Dispose();
                     }
@@ -564,7 +568,8 @@ private void Dispose(bool disposing)
 
         private struct GlyphRenderData : IDisposable
         {
-            // public Color? Color;
+            public Vector2 LocationDelta;
+
             public Buffer2D<float> FillMap;
 
             public Buffer2D<float> OutlineMap;

src/ImageSharp.Drawing/Shapes/PathBuilder.cs

@@ -65,7 +65,7 @@ public PathBuilder SetOrigin(PointF origin)
         }
 
         /// <summary>
-        /// Resets the translation to the default.
+        /// Resets the transform to the default.
         /// </summary>
         /// <returns>The <see cref="PathBuilder"/>.</returns>
         public PathBuilder ResetTransform()
@@ -451,8 +451,6 @@ public void Clear()
             this.currentFigure = new Figure();
             this.figures.Clear();
             this.figures.Add(this.currentFigure);
-
-            // TODO: Should we reset currentPoint here instead?
         }
 
         private class Figure

src/ImageSharp.Drawing/Shapes/Rasterization/PolygonScanner.cs

@@ -14,21 +14,21 @@ internal ref struct PolygonScanner
         private readonly int minY;
         private readonly int maxY;
         private readonly IntersectionRule intersectionRule;
-        private ScanEdgeCollection edgeCollection;
-        private Span<ScanEdge> edges;
+        private readonly ScanEdgeCollection edgeCollection;
+        private readonly Span<ScanEdge> edges;
 
         // Common contiguous buffer for sorted0, sorted1, intersections, activeEdges [,intersectionTypes]
-        private IMemoryOwner<int> dataBuffer;
+        private readonly IMemoryOwner<int> dataBuffer;
 
         // | <- edgeCnt -> | <- edgeCnt -> | <- edgeCnt -> | <- maxIntersectionCount -> | <- maxIntersectionCount -> |
         // |---------------|---------------|---------------|----------------------------|----------------------------|
         // | sorted0       | sorted1       | activeEdges   | intersections              | intersectionTypes          |
         // |---------------|---------------|---------------|----------------------------|----------------------------|
-        private Span<int> sorted0;
-        private Span<int> sorted1;
+        private readonly Span<int> sorted0;
+        private readonly Span<int> sorted1;
         private ActiveEdgeList activeEdges;
-        private Span<float> intersections;
-        private Span<NonZeroIntersectionType> intersectionTypes;
+        private readonly Span<float> intersections;
+        private readonly Span<NonZeroIntersectionType> intersectionTypes;
 
         private int idx0;
         private int idx1;
@@ -192,11 +192,9 @@ public bool MoveToNextSubpixelScanLine()
         }
 
         public ReadOnlySpan<float> ScanCurrentLine()
-        {
-            return this.intersectionRule == IntersectionRule.OddEven
-                ? this.activeEdges.ScanOddEven(this.SubPixelY, this.edges, this.intersections)
-                : this.activeEdges.ScanNonZero(this.SubPixelY, this.edges, this.intersections, this.intersectionTypes);
-        }
+            => this.intersectionRule == IntersectionRule.OddEven
+            ? this.activeEdges.ScanOddEven(this.SubPixelY, this.edges, this.intersections)
+            : this.activeEdges.ScanNonZero(this.SubPixelY, this.edges, this.intersections, this.intersectionTypes);
 
         public void Dispose()
         {

src/ImageSharp.Drawing/Shapes/Text/BaseGlyphBuilder.cs

@@ -21,6 +21,12 @@ internal class BaseGlyphBuilder : IGlyphRenderer
         /// </summary>
         public BaseGlyphBuilder() => this.Builder = new PathBuilder();
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseGlyphBuilder"/> class.
+        /// </summary>
+        /// <param name="transform">The default transform.</param>
+        public BaseGlyphBuilder(Matrix3x2 transform) => this.Builder = new PathBuilder(transform);
+
         /// <summary>
         /// Gets the paths that have been rendered by the current instance.
         /// </summary>