Add WebGPU scene support & optimize encoding

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUSceneDispatch.cs

@@ -76,8 +76,10 @@ public static bool TryCreateStagedScene<TPixel>(
             return false;
         }
 
-        if (!WebGPUSceneEncoder.TryValidateBrushSupport(commands, out error))
+        WebGPUSceneSupportResult support = WebGPUSceneEncoder.ValidateSceneSupport(commands);
+        if (!support.IsSupported)
         {
+            error = support.Error;
             return false;
         }
 
@@ -97,7 +99,7 @@ public static bool TryCreateStagedScene<TPixel>(
 
         try
         {
-            encodedScene = WebGPUSceneEncoder.Encode(commands, flushContext.TargetBounds, flushContext.MemoryAllocator);
+            encodedScene = WebGPUSceneEncoder.Encode(commands, support, flushContext.TargetBounds, flushContext.MemoryAllocator);
             WebGPUSceneConfig config = WebGPUSceneConfig.Create(encodedScene);
             uint baseColor = 0U;
             if (!TryValidateBindingSizes(encodedScene, config, out error))

src/ImageSharp.Drawing.WebGPU/WebGPUSceneEncoder.cs

@@ -110,6 +110,8 @@ public LinearGeometry ToLinearGeometry()
         int pointCount = 0;
         int contourCount = 0;
         int segmentCount = 0;
+        int nonHorizontalSegmentCountPixelBoundary = 0;
+        int nonHorizontalSegmentCountPixelCenter = 0;
 
         bool hasBounds = false;
         float minX = float.MaxValue;
@@ -136,6 +138,8 @@ public LinearGeometry ToLinearGeometry()
             pointCount += geometry.Info.PointCount;
             contourCount += geometry.Info.ContourCount;
             segmentCount += geometry.Info.SegmentCount;
+            nonHorizontalSegmentCountPixelBoundary += geometry.Info.NonHorizontalSegmentCountPixelBoundary;
+            nonHorizontalSegmentCountPixelCenter += geometry.Info.NonHorizontalSegmentCountPixelCenter;
         }
 
         PointF[] points = new PointF[pointCount];
@@ -183,7 +187,9 @@ public LinearGeometry ToLinearGeometry()
                 Bounds = bounds,
                 ContourCount = contours.Length,
                 PointCount = points.Length,
-                SegmentCount = segmentCount
+                SegmentCount = segmentCount,
+                NonHorizontalSegmentCountPixelBoundary = nonHorizontalSegmentCountPixelBoundary,
+                NonHorizontalSegmentCountPixelCenter = nonHorizontalSegmentCountPixelCenter
             },
             contours,
             points);

src/ImageSharp.Drawing/ComplexPolygon.cs

@@ -16,7 +16,9 @@ public sealed class EmptyPath : IPath
             Bounds = RectangleF.Empty,
             ContourCount = 0,
             PointCount = 0,
-            SegmentCount = 0
+            SegmentCount = 0,
+            NonHorizontalSegmentCountPixelBoundary = 0,
+            NonHorizontalSegmentCountPixelCenter = 0
         },
         [],
         []);

src/ImageSharp.Drawing/EmptyPath.cs

@@ -31,4 +31,22 @@ public readonly struct LinearGeometryInfo
     /// Gets the total number of derived linear segments across all contours.
     /// </summary>
     public required int SegmentCount { get; init; }
+
+    /// <summary>
+    /// Gets the number of derived segments that remain non-horizontal when sampled on pixel boundaries.
+    /// </summary>
+    /// <remarks>
+    /// A segment contributes to this count when its start and end sample into different rows under
+    /// pixel-boundary sampling.
+    /// </remarks>
+    public required int NonHorizontalSegmentCountPixelBoundary { get; init; }
+
+    /// <summary>
+    /// Gets the number of derived segments that remain non-horizontal when sampled at pixel centers.
+    /// </summary>
+    /// <remarks>
+    /// A segment contributes to this count when its start and end sample into different rows after the
+    /// half-pixel center-sampling offset is applied.
+    /// </remarks>
+    public required int NonHorizontalSegmentCountPixelCenter { get; init; }
 }

src/ImageSharp.Drawing/LinearGeometryInfo.cs

@@ -146,7 +146,9 @@ public virtual LinearGeometry ToLinearGeometry()
                     Bounds = RectangleF.Empty,
                     ContourCount = 0,
                     PointCount = 0,
-                    SegmentCount = 0
+                    SegmentCount = 0,
+                    NonHorizontalSegmentCountPixelBoundary = 0,
+                    NonHorizontalSegmentCountPixelCenter = 0
                 },
                 [],
                 []);
@@ -173,6 +175,8 @@ public virtual LinearGeometry ToLinearGeometry()
         float minY = float.MaxValue;
         float maxX = float.MinValue;
         float maxY = float.MinValue;
+        int nonHorizontalSegmentCountPixelBoundary = 0;
+        int nonHorizontalSegmentCountPixelCenter = 0;
         int pointIndex = 0;
         lastEndPoint = null;
 
@@ -200,6 +204,7 @@ public virtual LinearGeometry ToLinearGeometry()
         }
 
         int segmentCount = pointCount == 0 ? 0 : this.IsClosed ? pointCount : pointCount - 1;
+        CountNonHorizontalSegments(points, pointCount, this.IsClosed, ref nonHorizontalSegmentCountPixelBoundary, ref nonHorizontalSegmentCountPixelCenter);
 
         if (pointCount > 0)
         {
@@ -221,7 +226,9 @@ public virtual LinearGeometry ToLinearGeometry()
                 Bounds = bounds,
                 ContourCount = contours.Length,
                 PointCount = points.Length,
-                SegmentCount = segmentCount
+                SegmentCount = segmentCount,
+                NonHorizontalSegmentCountPixelBoundary = nonHorizontalSegmentCountPixelBoundary,
+                NonHorizontalSegmentCountPixelCenter = nonHorizontalSegmentCountPixelCenter
             },
             contours,
             points);
@@ -257,12 +264,68 @@ private RectangleF CalculateBounds()
         return bounds;
     }
 
+    /// <summary>
+    /// Materializes the segment sequence into the retained array used by the path.
+    /// </summary>
+    /// <param name="segments">The segment sequence to materialize.</param>
+    /// <returns>The retained segment array.</returns>
     private static ILineSegment[] GetSegmentArray(IEnumerable<ILineSegment> segments)
     {
         Guard.NotNull(segments, nameof(segments));
         return segments as ILineSegment[] ?? [.. segments];
     }
 
+    /// <summary>
+    /// Counts how many derived segments survive as non-horizontal raster work for each sampling origin.
+    /// </summary>
+    /// <param name="points">The retained contour point run.</param>
+    /// <param name="pointCount">The number of retained points in the contour.</param>
+    /// <param name="isClosed">Whether the contour closes back to its first point.</param>
+    /// <param name="nonHorizontalSegmentCountPixelBoundary">The accumulated pixel-boundary count to update.</param>
+    /// <param name="nonHorizontalSegmentCountPixelCenter">The accumulated pixel-center count to update.</param>
+    private static void CountNonHorizontalSegments(
+        ReadOnlySpan<PointF> points,
+        int pointCount,
+        bool isClosed,
+        ref int nonHorizontalSegmentCountPixelBoundary,
+        ref int nonHorizontalSegmentCountPixelCenter)
+    {
+        if (pointCount <= 1)
+        {
+            return;
+        }
+
+        int segmentCount = isClosed ? pointCount : pointCount - 1;
+        for (int i = 0; i < segmentCount; i++)
+        {
+            PointF start = points[i];
+            PointF end = points[(i + 1) == pointCount ? 0 : i + 1];
+            if (ToFixedBoundary(start.Y) != ToFixedBoundary(end.Y))
+            {
+                nonHorizontalSegmentCountPixelBoundary++;
+            }
+
+            if (ToFixedCenter(start.Y) != ToFixedCenter(end.Y))
+            {
+                nonHorizontalSegmentCountPixelCenter++;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Converts a coordinate to the fixed-point row space used by boundary-sampled raster work.
+    /// </summary>
+    /// <param name="value">The coordinate to convert.</param>
+    /// <returns>The rounded 24.8 fixed-point value.</returns>
+    private static int ToFixedBoundary(float value) => (int)MathF.Round(value * 256F);
+
+    /// <summary>
+    /// Converts a coordinate to the fixed-point row space used by center-sampled raster work.
+    /// </summary>
+    /// <param name="value">The coordinate to convert.</param>
+    /// <returns>The rounded 24.8 fixed-point value after the half-pixel sampling offset is applied.</returns>
+    private static int ToFixedCenter(float value) => (int)MathF.Round((value + 0.5F) * 256F);
+
     /// <summary>
     /// Converts an SVG path string into an <see cref="IPath"/>.
     /// </summary>

src/ImageSharp.Drawing/Path.cs

@@ -253,7 +253,9 @@ public LinearGeometry ToLinearGeometry()
                 Bounds = this.Bounds,
                 ContourCount = 1,
                 PointCount = 4,
-                SegmentCount = 4
+                SegmentCount = 4,
+                NonHorizontalSegmentCountPixelBoundary = 2,
+                NonHorizontalSegmentCountPixelCenter = 2
             },
             contours,
             points);