Add slowpath transform

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Backends/CompositionSceneCommandBase.cs

@@ -56,7 +56,7 @@ public PathCompositionSceneCommand(in CompositionCommand command)
     /// <summary>
     /// Gets the wrapped composition command.
     /// </summary>
-    public CompositionCommand Command { get; }
+    public CompositionCommand Command { get; internal set; }
 
     /// <inheritdoc />
     public override void Accept(ICompositionSceneCommandVisitor visitor) => visitor.Visit(this);

src/ImageSharp.Drawing/Processing/Backends/FlushScene.cs

@@ -695,7 +695,8 @@ private static bool TryPrepareFillPath(
         MemoryAllocator allocator,
         out PreparedFillItem prepared)
     {
-        IPath path = ResolveCommandPath(command);
+        IPath path = command.SourcePath;
+
         if (!TryResolveRasterization(
                 command.Brush,
                 path.Bounds,
@@ -716,6 +717,7 @@ private static bool TryPrepareFillPath(
             command.DestinationOffset.Y,
             rasterizerOptions,
             allocator);
+
         if (rasterizable is null)
         {
             prepared = default;
@@ -732,7 +734,7 @@ private static bool TryPrepareStrokePath(
         MemoryAllocator allocator,
         out PreparedStrokeItem prepared)
     {
-        IPath path = ResolveCommandPath(command);
+        IPath path = command.SourcePath;
 
         if (!TryResolveRasterization(
                 command.Brush,
@@ -793,6 +795,7 @@ private static bool TryPrepareLineSegmentStroke(
             command.DestinationOffset.X,
             command.DestinationOffset.Y,
             rasterizerOptions);
+
         if (rasterizable is null)
         {
             prepared = default;
@@ -841,18 +844,6 @@ private static bool TryPreparePolylineStroke(
         return true;
     }
 
-    private static IPath ResolveCommandPath(in CompositionCommand command)
-    {
-        IPath path = command.SourcePath;
-
-        if (command.ClipPaths is { Count: > 0 })
-        {
-            path = path.Clip(command.ShapeOptions, command.ClipPaths);
-        }
-
-        return path;
-    }
-
     private static bool TryResolveRasterization(
         Brush brush,
         RectangleF bounds,
@@ -896,6 +887,7 @@ private static bool TryResolveRasterization(
             options.RasterizationMode,
             options.SamplingOrigin,
             options.AntialiasThreshold);
+
         brushBounds = absoluteInterest;
         return true;
     }

src/ImageSharp.Drawing/Processing/DrawingCanvasBatcher{TPixel}.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.ImageSharp.Drawing.Processing.Backends;
 
 namespace SixLabors.ImageSharp.Drawing.Processing;
@@ -22,6 +23,7 @@ internal sealed class DrawingCanvasBatcher<TPixel>
     private CompositionSceneCommand[] commands;
     private int commandCount;
     private bool hasLayers;
+    private bool hasClips;
 
     internal DrawingCanvasBatcher(
         Configuration configuration,
@@ -48,6 +50,7 @@ public void AddComposition(in CompositionCommand composition)
         this.EnsureCommandCapacity(this.commandCount + 1);
         this.commands[this.commandCount++] = new PathCompositionSceneCommand(composition);
         this.hasLayers |= composition.Kind is not CompositionCommandKind.FillLayer;
+        this.hasClips |= composition.ClipPaths is not null;
     }
 
     /// <summary>
@@ -86,9 +89,10 @@ public void FlushCompositions()
 
         try
         {
-            CompositionScene scene = new(
-                new ArraySegment<CompositionSceneCommand>(this.commands, 0, this.commandCount),
-                this.hasLayers);
+            this.ApplyClipping();
+
+            CompositionScene scene = new(this.commands, this.hasLayers);
+
             this.backend.FlushCompositions(this.configuration, this.TargetFrame, scene);
         }
         finally
@@ -118,4 +122,51 @@ private void EnsureCommandCapacity(int requiredCapacity)
 
         Array.Resize(ref this.commands, nextCapacity);
     }
+
+    private void ApplyClipping()
+    {
+        if (!this.hasClips)
+        {
+            return;
+        }
+
+        _ = Parallel.For(0, this.commandCount, i =>
+        {
+            CompositionSceneCommand command = this.commands[i];
+            if (command is PathCompositionSceneCommand pathCommand)
+            {
+                CompositionCommand composition = pathCommand.Command;
+
+                // If clipping is present we need to apply that now before handing the command
+                // to the backend. This avoids complicating the backend with clipping logic
+                // and allows us to reuse the same optimized backend code for clipped and unclipped paths.
+                if (composition.ClipPaths is { Count: > 0 })
+                {
+                    IPath path = composition.SourcePath;
+
+                    path = path.Transform(composition.Transform);
+
+                    if (composition.Pen is not null)
+                    {
+                        path = path.GenerateOutline(composition.Pen.StrokeWidth);
+                    }
+
+                    path = path.Clip(composition.ShapeOptions, composition.ClipPaths);
+
+                    RasterizerOptions rasterizerOptions = composition.RasterizerOptions;
+
+                    // Update the command with the clipped path.
+                    pathCommand.Command = CompositionCommand.Create(
+                        path,
+                        composition.Brush.Transform(composition.Transform),
+                        composition.GraphicsOptions,
+                        in rasterizerOptions,
+                        composition.ShapeOptions,
+                        Matrix4x4.Identity,
+                        composition.TargetBounds,
+                        composition.DestinationOffset);
+                }
+            }
+        });
+    }
 }