Add per-band stroke rasterization and StrokeEdgeFlags

Author: JimBobSquarePants

samples/WebGPUWindowDemo/Program.cs

@@ -155,9 +155,7 @@ private static void OnLoad()
 
         Console.WriteLine($"Device: 0x{(nuint)device:X}, Queue: 0x{(nuint)queue:X}");
 
-        // Query surface capabilities and configure the swap chain.
-        wgpu.SurfaceGetCapabilities(surface, adapter, ref surfaceCapabilities);
-        Console.WriteLine($"Surface format: {surfaceCapabilities.Formats[0]}");
+        // Configure the swap chain.
         ConfigureSwapchain();
 
         // Initialize the ImageSharp.Drawing WebGPU backend and attach it to a

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.CoverageRasterizer.cs

@@ -823,7 +823,7 @@ private static bool TryBuildStrokeEdges(
                     Y0 = vy,
                     X1 = (int)MathF.Round(((pv.X - interestX) + samplingOffsetX) * FixedOne),
                     Y1 = (int)MathF.Round(((pv.Y - interestY) + samplingOffsetY) * FixedOne),
-                    Flags = 32, // EDGE_JOIN
+                    Flags = StrokeEdgeFlags.Join,
                     AdjX = (int)MathF.Round(((nv.X - interestX) + samplingOffsetX) * FixedOne),
                     AdjY = (int)MathF.Round(((nv.Y - interestY) + samplingOffsetY) * FixedOne),
                 });
@@ -844,7 +844,7 @@ private static bool TryBuildStrokeEdges(
                     Y0 = csy,
                     X1 = (int)MathF.Round(((adjStart.X - interestX) + samplingOffsetX) * FixedOne),
                     Y1 = (int)MathF.Round(((adjStart.Y - interestY) + samplingOffsetY) * FixedOne),
-                    Flags = 64, // EDGE_CAP_START
+                    Flags = StrokeEdgeFlags.CapStart,
                 });
 
                 edgeYRanges.Add((csy - yExpansionFixed, csy + yExpansionFixed));
@@ -859,7 +859,7 @@ private static bool TryBuildStrokeEdges(
                     Y0 = cey,
                     X1 = (int)MathF.Round(((adjEnd.X - interestX) + samplingOffsetX) * FixedOne),
                     Y1 = (int)MathF.Round(((adjEnd.Y - interestY) + samplingOffsetY) * FixedOne),
-                    Flags = 128, // EDGE_CAP_END
+                    Flags = StrokeEdgeFlags.CapEnd,
                 });
 
                 edgeYRanges.Add((cey - yExpansionFixed, cey + yExpansionFixed));
@@ -1191,12 +1191,9 @@ private struct GpuEdge
         public int Y1;
 
         /// <summary>
-        /// Bit flags for stroke edge metadata.
-        /// Bit 0: open start — the (X0,Y0) endpoint is an open path start (cap applies).
-        /// Bit 1: open end — the (X1,Y1) endpoint is an open path end (cap applies).
-        /// Bit 2: bevel fill — this edge is a bevel fill chord (AdjX,AdjY = join vertex).
+        /// Stroke edge type flags matching the WGSL shader constants.
         /// </summary>
-        public int Flags;
+        public StrokeEdgeFlags Flags;
 
         /// <summary>
         /// Auxiliary coordinates (fixed-point). For bevel fill edges, stores the

…Sharp.Drawing.WebGPU/DashPathSplitter.cs …/Processing/Backends/DashPathSplitter.cssrc/ImageSharp.Drawing.WebGPU/DashPathSplitter.cs renamed to src/ImageSharp.Drawing/Processing/Backends/DashPathSplitter.cs src/ImageSharp.Drawing.WebGPU/DashPathSplitter.cs renamed to src/ImageSharp.Drawing/Processing/Backends/DashPathSplitter.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// Splits a path into dash segments without performing stroke expansion.
 /// Each "on" dash segment is returned as an open sub-path.
 /// </summary>
-internal static class DashPathSplitter
+public static class DashPathSplitter
 {
     /// <summary>
     /// Splits the given path into dash segments based on the provided pattern.

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

@@ -155,26 +155,30 @@ private void FlushPreparedBatch<TPixel>(
 
         CompositionCoverageDefinition definition = compositionBatch.Definition;
 
-        // When the definition carries stroke metadata, expand the centerline
-        // path into a filled outline before rasterization.
         IPath rasterPath = definition.Path;
         RasterizerOptions rasterizerOptions = definition.RasterizerOptions;
 
-        if (definition.IsStroke)
+        if (definition.IsStroke && definition.StrokePattern.Length > 0)
         {
-            rasterPath = definition.StrokePattern.Length > 0
-                ? rasterPath.GenerateOutline(definition.StrokeWidth, definition.StrokePattern.Span, definition.StrokeOptions!)
-                : rasterPath.GenerateOutline(definition.StrokeWidth, definition.StrokeOptions!);
-
-            // Compute the exact interest from the actual stroke outline bounds
-            // so band boundaries and coverage values match the old canvas-side path.
-            RectangleF outlineBounds = rasterPath.Bounds;
-            outlineBounds = new RectangleF(outlineBounds.X + 0.5F, outlineBounds.Y + 0.5F, outlineBounds.Width, outlineBounds.Height);
+            // Dashed strokes: split into dash segments on the CPU, then stroke-expand
+            // each segment via the per-band parallel path (same as solid strokes).
+            rasterPath = DashPathSplitter.SplitDashes(rasterPath, definition.StrokeWidth, definition.StrokePattern.Span);
+
+            // Recompute interest from the split path bounds with stroke expansion.
+            float halfWidth = definition.StrokeWidth * 0.5f;
+            float maxExtent = halfWidth * Math.Max((float)(definition.StrokeOptions?.MiterLimit ?? 4.0), 1.0f);
+            RectangleF pathBounds = rasterPath.Bounds;
+            pathBounds = new RectangleF(
+                pathBounds.X + 0.5F - maxExtent,
+                pathBounds.Y + 0.5F - maxExtent,
+                pathBounds.Width + (maxExtent * 2),
+                pathBounds.Height + (maxExtent * 2));
+
             Rectangle interest = Rectangle.FromLTRB(
-                (int)MathF.Floor(outlineBounds.Left),
-                (int)MathF.Floor(outlineBounds.Top),
-                (int)MathF.Ceiling(outlineBounds.Right),
-                (int)MathF.Ceiling(outlineBounds.Bottom));
+                (int)MathF.Floor(pathBounds.Left),
+                (int)MathF.Floor(pathBounds.Top),
+                (int)MathF.Ceiling(pathBounds.Right),
+                (int)MathF.Ceiling(pathBounds.Bottom));
 
             rasterizerOptions = new RasterizerOptions(
                 interest,
@@ -183,7 +187,7 @@ private void FlushPreparedBatch<TPixel>(
                 rasterizerOptions.SamplingOrigin,
                 rasterizerOptions.AntialiasThreshold);
 
-            // Re-prepare commands with the actual outline interest so destination
+            // Re-prepare commands with the dash-split interest so destination
             // regions and source offsets are aligned with the rasterizer.
             CompositionScenePlanner.ReprepareBatchCommands(compositionBatch.Commands, target.Bounds, interest);
         }
@@ -213,12 +217,29 @@ private void FlushPreparedBatch<TPixel>(
                 destinationBounds,
                 rasterizerOptions.Interest.Top);
 
-            DefaultRasterizer.RasterizeRows(
-                rasterPath,
-                rasterizerOptions,
-                configuration.MemoryAllocator,
-                operation.InvokeCoverageRow,
-                ref reusableScratch);
+            if (definition.IsStroke)
+            {
+                // All strokes (solid and dashed) use per-band parallel stroke expansion.
+                DefaultRasterizer.RasterizeStrokeRows(
+                    rasterPath,
+                    rasterizerOptions,
+                    configuration.MemoryAllocator,
+                    operation.InvokeCoverageRow,
+                    ref reusableScratch,
+                    definition.StrokeWidth,
+                    definition.StrokeOptions!.LineJoin,
+                    definition.StrokeOptions!.LineCap,
+                    (float)definition.StrokeOptions!.MiterLimit);
+            }
+            else
+            {
+                DefaultRasterizer.RasterizeRows(
+                    rasterPath,
+                    rasterizerOptions,
+                    configuration.MemoryAllocator,
+                    operation.InvokeCoverageRow,
+                    ref reusableScratch);
+            }
         }
         finally
         {