Add AntialiasThreshold and aliased mode

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/Shaders/CompositeComputeShader.cs

@@ -51,6 +51,8 @@ struct Params {
             solid_g: u32,
             solid_b: u32,
             solid_a: u32,
+            rasterization_mode: u32,
+            antialias_threshold: u32,
         };
 
         struct DispatchConfig {
@@ -766,7 +768,7 @@ fn rasterize_edge(edge: Edge, band_top: i32, band_left_fixed: i32, clip_top_fixe
             rasterize_line(clipped.x0, clipped.y0 - band_top_fixed, clipped.x1, clipped.y1 - band_top_fixed);
         }
 
-        fn area_to_coverage(area_val: i32, fill_rule: u32) -> f32 {
+        fn area_to_coverage(area_val: i32, fill_rule: u32, rasterization_mode: u32, antialias_threshold: f32) -> f32 {
             let signed_area = area_val >> AREA_SHIFT;
             var abs_area: i32;
             if signed_area < 0 {
@@ -794,6 +796,14 @@ fn area_to_coverage(area_val: i32, fill_rule: u32) -> f32 {
                     coverage = f32(wrapped) * COV_SCALE;
                 }
             }
+            // Aliased mode: snap to binary coverage using threshold
+            if rasterization_mode == 1u {
+                if coverage >= antialias_threshold {
+                    coverage = 1.0;
+                } else {
+                    coverage = 0.0;
+                }
+            }
             return coverage;
         }
 
@@ -923,7 +933,7 @@ fn cs_main(
                             cover += atomicLoad(&tile_cover[py * 16u + col]);
                         }
                         let area_val = atomicLoad(&tile_area[py * 16u + px]) + (cover << AREA_SHIFT);
-                        let coverage_value = area_to_coverage(area_val, command.fill_rule_value);
+                        let coverage_value = area_to_coverage(area_val, command.fill_rule_value, command.rasterization_mode, u32_to_f32(command.antialias_threshold));
 
                         if coverage_value > 0.0 {
                             let blend_percentage = u32_to_f32(command.blend_percentage);

src/ImageSharp.Drawing.WebGPU/WEBGPU_BACKEND_PROCESS.md

@@ -23,6 +23,7 @@ DrawingCanvasBatcher.Flush()
         -> use target texture view directly as backdrop source (no copy)
         -> allocate transient output texture for composition bounds
         -> deduplicate coverage definitions across batches via CoverageDefinitionIdentity
+           (keyed by path, interest, intersection rule, rasterization mode, sampling origin, antialias threshold)
         -> TryCreateEdgeBuffer (CPU-side edge preparation)
            -> for each unique coverage definition:
               -> path.Flatten() to iterate flattened vertices
@@ -52,6 +53,7 @@ DrawingCanvasBatcher.Flush()
                     -> X-range spatial filter: edges left of tile only update start_cover
                     -> barrier, then each thread accumulates its coverage from shared memory
                     -> applies fill rule (non-zero or even-odd)
+                    -> if aliased mode: snaps coverage to binary using antialias threshold
                     -> samples brush (solid color or image texture)
                     -> composes pixel using Porter-Duff alpha composition + color blend mode
                  -> writes final pixel to output texture
@@ -87,7 +89,7 @@ Each edge is a 32-byte `GpuEdge` struct (sequential layout):
 
 ### Command Parameters
 
-Each `PreparedCompositeParameters` struct contains destination rectangle, edge placement (start, fill rule, CSR offsets start, band count), brush configuration, blend/composition mode, and blend percentage.
+Each `PreparedCompositeParameters` struct (26 × u32 = 104 bytes) contains destination rectangle, edge placement (start, fill rule, CSR offsets start, band count), brush configuration, blend/composition mode, blend percentage, rasterization mode (0 = antialiased, 1 = aliased), and antialias threshold (float as u32 bitcast).
 
 ### Dispatch Config
 

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -162,14 +162,6 @@ public void FillPath<TPixel>(
                 target.Bounds.Location));
     }
 
-    /// <inheritdoc />
-    public bool IsCompositionBrushSupported<TPixel>(Brush brush)
-        where TPixel : unmanaged, IPixel<TPixel>
-    {
-        this.ThrowIfDisposed();
-        return IsSupportedCompositionBrush(brush);
-    }
-
     /// <inheritdoc />
     public void FlushCompositions<TPixel>(
         Configuration configuration,
@@ -733,7 +725,9 @@ bool LayoutFactory(WebGPU api, Device* device, out BindGroupLayout* layout, out
                     (uint)command.GraphicsOptions.ColorBlendingMode,
                     (uint)command.GraphicsOptions.AlphaCompositionMode,
                     command.GraphicsOptions.BlendPercentage,
-                    solidColor);
+                    solidColor,
+                    command.GraphicsOptions.Antialias ? 0u : 1u,
+                    command.GraphicsOptions.AntialiasThreshold);
 
                     parameters[commandIndex] = commandParameters;
                     commandIndex++;
@@ -1623,6 +1617,7 @@ private static bool WaitForSignal(WebGPUFlushContext flushContext, ManualResetEv
         private readonly IntersectionRule intersectionRule;
         private readonly RasterizationMode rasterizationMode;
         private readonly RasterizerSamplingOrigin samplingOrigin;
+        private readonly float antialiasThreshold;
 
         public CoverageDefinitionIdentity(in CompositionCoverageDefinition definition)
         {
@@ -1632,6 +1627,7 @@ public CoverageDefinitionIdentity(in CompositionCoverageDefinition definition)
             this.intersectionRule = definition.RasterizerOptions.IntersectionRule;
             this.rasterizationMode = definition.RasterizerOptions.RasterizationMode;
             this.samplingOrigin = definition.RasterizerOptions.SamplingOrigin;
+            this.antialiasThreshold = definition.RasterizerOptions.AntialiasThreshold;
         }
 
         /// <summary>
@@ -1645,7 +1641,8 @@ public bool Equals(CoverageDefinitionIdentity other)
                this.interest.Equals(other.interest) &&
                this.intersectionRule == other.intersectionRule &&
                this.rasterizationMode == other.rasterizationMode &&
-               this.samplingOrigin == other.samplingOrigin;
+               this.samplingOrigin == other.samplingOrigin &&
+               this.antialiasThreshold == other.antialiasThreshold;
 
         /// <inheritdoc/>
         public override bool Equals(object? obj)
@@ -1659,7 +1656,8 @@ public override int GetHashCode()
                 this.interest,
                 (int)this.intersectionRule,
                 (int)this.rasterizationMode,
-                (int)this.samplingOrigin);
+                (int)this.samplingOrigin,
+                this.antialiasThreshold);
     }
 
     private readonly struct EdgePlacement
@@ -1746,7 +1744,7 @@ public PreparedCompositeDispatchConfig(
 
     /// <summary>
     /// Prepared composite command parameters consumed by <see cref="CompositeComputeShader"/>.
-    /// Layout matches the WGSL <c>Params</c> struct exactly (24 u32 fields = 96 bytes).
+    /// Layout matches the WGSL <c>Params</c> struct exactly (26 u32 fields = 104 bytes).
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     private readonly struct PreparedCompositeParameters
@@ -1775,6 +1773,8 @@ private readonly struct PreparedCompositeParameters
         public readonly uint SolidG;
         public readonly uint SolidB;
         public readonly uint SolidA;
+        public readonly uint RasterizationMode;
+        public readonly uint AntialiasThreshold;
 
         public PreparedCompositeParameters(
             int destinationX,
@@ -1797,7 +1797,9 @@ public PreparedCompositeParameters(
             uint colorBlendMode,
             uint alphaCompositionMode,
             float blendPercentage,
-            Vector4 solidColor)
+            Vector4 solidColor,
+            uint rasterizationMode,
+            float antialiasThreshold)
         {
             this.DestinationX = (uint)destinationX;
             this.DestinationY = (uint)destinationY;
@@ -1823,6 +1825,8 @@ public PreparedCompositeParameters(
             this.SolidG = FloatToUInt32Bits(solidColor.Y);
             this.SolidB = FloatToUInt32Bits(solidColor.Z);
             this.SolidA = FloatToUInt32Bits(solidColor.W);
+            this.RasterizationMode = rasterizationMode;
+            this.AntialiasThreshold = FloatToUInt32Bits(antialiasThreshold);
         }
     }
 }

src/ImageSharp.Drawing/ImageSharp.Drawing.csproj

@@ -50,11 +50,11 @@
     <None Include="..\..\shared-infrastructure\branding\icons\imagesharp.drawing\sixlabors.imagesharp.drawing.128.png" Pack="true" PackagePath="" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="SixLabors.Fonts" Version="3.0.0-alpha.0.19" />
-    <PackageReference Include="SixLabors.ImageSharp" Version="4.0.0-alpha.0.72" />
+    <PackageReference Include="SixLabors.Fonts" Version="3.0.0-alpha.0.23" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="4.0.0-alpha.0.78" />
     <PackageReference Include="SixLabors.PolygonClipper" Version="1.0.0-alpha.0.52" />
   </ItemGroup>
-
+  
   <Import Project="..\..\shared-infrastructure\src\SharedInfrastructure\SharedInfrastructure.projitems" Label="Shared" />
 
 </Project>

src/ImageSharp.Drawing/PathBuilder.cs

@@ -465,7 +465,7 @@ public PathBuilder Reset()
     /// <summary>
     /// Clears all drawn paths, Leaving any applied transforms.
     /// </summary>
-    [MemberNotNull(nameof(this.currentFigure))]
+    [MemberNotNull(nameof(currentFigure))]
     public void Clear()
     {
         this.currentFigure = new Figure();
@@ -485,7 +485,7 @@ private class Figure
 
         public IPath Build()
             => this.IsClosed
-            ? new Polygon(this.segments.ToArray(), true)
+            ? new Polygon([.. this.segments], true)
             : new Path(this.segments.ToArray());
     }
 }

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

@@ -38,11 +38,6 @@ internal sealed class DefaultDrawingBackend : IDrawingBackend
     /// </summary>
     public static DefaultDrawingBackend Instance { get; } = new();
 
-    /// <inheritdoc />
-    public bool IsCompositionBrushSupported<TPixel>(Brush brush)
-        where TPixel : unmanaged, IPixel<TPixel>
-        => true;
-
     /// <inheritdoc />
     public void FillPath<TPixel>(
         ICanvasFrame<TPixel> target,

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

@@ -182,6 +182,7 @@ private static void RasterizeCoreRows(
                 maxBandRows,
                 options.IntersectionRule,
                 options.RasterizationMode,
+                options.AntialiasThreshold,
                 allocator,
                 rowHandler,
                 ref reusableScratch))
@@ -199,6 +200,7 @@ private static void RasterizeCoreRows(
             maxBandRows,
             options.IntersectionRule,
             options.RasterizationMode,
+            options.AntialiasThreshold,
             allocator,
             rowHandler,
             ref reusableScratch);
@@ -216,6 +218,9 @@ private static void RasterizeCoreRows(
     /// <param name="maxBandRows">Maximum rows per reusable scratch band.</param>
     /// <param name="intersectionRule">Fill rule.</param>
     /// <param name="rasterizationMode">Coverage mode (AA or aliased).</param>
+    /// <param name="antialiasThreshold">
+    /// Antialiasing threshold in [0, 1] when <paramref name="rasterizationMode"/> is AA.
+    /// </param>
     /// <param name="allocator">Temporary buffer allocator.</param>
     /// <param name="rowHandler">Coverage row callback invoked once per emitted row.</param>
     /// <param name="reusableScratch">
@@ -232,6 +237,7 @@ private static void RasterizeSequentialBands(
         int maxBandRows,
         IntersectionRule intersectionRule,
         RasterizationMode rasterizationMode,
+        float antialiasThreshold,
         MemoryAllocator allocator,
         RasterizerCoverageRowHandler rowHandler,
         ref WorkerScratch? reusableScratch)
@@ -280,7 +286,7 @@ private static void RasterizeSequentialBands(
                     continue;
                 }
 
-                Context context = scratch.CreateContext(currentBandHeight, intersectionRule, rasterizationMode);
+                Context context = scratch.CreateContext(currentBandHeight, intersectionRule, rasterizationMode, antialiasThreshold);
                 context.RasterizeEdgeTable(sortedEdges.Slice(start, length), bandTop);
                 context.EmitCoverageRows(interestTop + bandTop, scratch.Scanline, rowHandler);
                 context.ResetTouchedRows();
@@ -301,6 +307,9 @@ private static void RasterizeSequentialBands(
     /// <param name="maxBandRows">Maximum rows per worker scratch context.</param>
     /// <param name="intersectionRule">Fill rule.</param>
     /// <param name="rasterizationMode">Coverage mode (AA or aliased).</param>
+    /// <param name="antialiasThreshold">
+    /// Antialiasing threshold in [0, 1] when <paramref name="rasterizationMode"/> is AA.
+    /// </param>
     /// <param name="allocator">Temporary buffer allocator.</param>
     /// <param name="rowHandler">Coverage row callback invoked once per emitted row.</param>
     /// <param name="reusableScratch">Caller-managed scratch. Reused when compatible; replaced and updated in place otherwise.</param>
@@ -319,6 +328,7 @@ private static bool TryRasterizeParallel(
         int maxBandRows,
         IntersectionRule intersectionRule,
         RasterizationMode rasterizationMode,
+        float antialiasThreshold,
         MemoryAllocator allocator,
         RasterizerCoverageRowHandler rowHandler,
         ref WorkerScratch? reusableScratch)
@@ -344,6 +354,7 @@ private static bool TryRasterizeParallel(
                 coverStride,
                 intersectionRule,
                 rasterizationMode,
+                antialiasThreshold,
                 allocator,
                 rowHandler,
                 ref reusableScratch);
@@ -398,7 +409,7 @@ private static bool TryRasterizeParallel(
                         if (length > 0)
                         {
                             ReadOnlySpan<EdgeData> tileEdges = sortedEdgesMemory.Span.Slice(start, length);
-                            context = worker.CreateContext(bandHeight, intersectionRule, rasterizationMode);
+                            context = worker.CreateContext(bandHeight, intersectionRule, rasterizationMode, antialiasThreshold);
                             context.RasterizeEdgeTable(tileEdges, bandTop);
                             hasCoverage = true;
                             context.EmitCoverageRows(interestTop + bandTop, worker.Scanline, rowHandler);
@@ -435,6 +446,9 @@ private static bool TryRasterizeParallel(
     /// <param name="coverStride">Cover-area stride in ints.</param>
     /// <param name="intersectionRule">Fill rule.</param>
     /// <param name="rasterizationMode">Coverage mode (AA or aliased).</param>
+    /// <param name="antialiasThreshold">
+    /// Antialiasing threshold in [0, 1] when <paramref name="rasterizationMode"/> is AA.
+    /// </param>
     /// <param name="allocator">Temporary buffer allocator.</param>
     /// <param name="rowHandler">Coverage row callback invoked once per emitted row.</param>
     /// <param name="reusableScratch">
@@ -450,6 +464,7 @@ private static void RasterizeSingleTileDirect(
         int coverStride,
         IntersectionRule intersectionRule,
         RasterizationMode rasterizationMode,
+        float antialiasThreshold,
         MemoryAllocator allocator,
         RasterizerCoverageRowHandler rowHandler,
         ref WorkerScratch? reusableScratch)
@@ -462,7 +477,7 @@ private static void RasterizeSingleTileDirect(
         }
 
         WorkerScratch scratch = reusableScratch;
-        Context context = scratch.CreateContext(height, intersectionRule, rasterizationMode);
+        Context context = scratch.CreateContext(height, intersectionRule, rasterizationMode, antialiasThreshold);
         context.RasterizeEdgeTable(edges, bandTop: 0);
         context.EmitCoverageRows(interestTop, scratch.Scanline, rowHandler);
         context.ResetTouchedRows();
@@ -865,6 +880,7 @@ internal ref struct Context
         private readonly int coverStride;
         private readonly IntersectionRule intersectionRule;
         private readonly RasterizationMode rasterizationMode;
+        private readonly float antialiasThreshold;
         private int touchedRowCount;
 
         /// <summary>
@@ -884,7 +900,8 @@ public Context(
             int wordsPerRow,
             int coverStride,
             IntersectionRule intersectionRule,
-            RasterizationMode rasterizationMode)
+            RasterizationMode rasterizationMode,
+            float antialiasThreshold)
         {
             this.bitVectors = bitVectors;
             this.coverArea = coverArea;
@@ -900,6 +917,7 @@ public Context(
             this.coverStride = coverStride;
             this.intersectionRule = intersectionRule;
             this.rasterizationMode = rasterizationMode;
+            this.antialiasThreshold = antialiasThreshold;
             this.touchedRowCount = 0;
         }
 
@@ -1252,8 +1270,9 @@ private readonly float AreaToCoverage(int area)
 
             if (this.rasterizationMode == RasterizationMode.Aliased)
             {
-                // Aliased mode quantizes final coverage to hard 0/1 per pixel.
-                return coverage >= 0.5F ? 1F : 0F;
+                // Aliased mode quantizes final coverage to hard 0/1 per pixel
+                // using the configurable threshold from GraphicsOptions.AntialiasThreshold.
+                return coverage >= this.antialiasThreshold ? 1F : 0F;
             }
 
             return coverage;
@@ -2156,7 +2175,7 @@ public static WorkerScratch Create(MemoryAllocator allocator, int wordsPerRow, i
         /// <summary>
         /// Creates a context view over this scratch for the requested band height.
         /// </summary>
-        public Context CreateContext(int bandHeight, IntersectionRule intersectionRule, RasterizationMode rasterizationMode)
+        public Context CreateContext(int bandHeight, IntersectionRule intersectionRule, RasterizationMode rasterizationMode, float antialiasThreshold)
         {
             if ((uint)bandHeight > (uint)this.tileCapacity)
             {
@@ -2179,7 +2198,8 @@ public Context CreateContext(int bandHeight, IntersectionRule intersectionRule,
                 this.wordsPerRow,
                 this.coverStride,
                 intersectionRule,
-                rasterizationMode);
+                rasterizationMode,
+                antialiasThreshold);
         }
 
         /// <summary>

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

@@ -14,17 +14,6 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// </remarks>
 internal interface IDrawingBackend
 {
-    /// <summary>
-    /// Determines whether the backend can compose the provided brush type directly for <typeparamref name="TPixel"/>.
-    /// </summary>
-    /// <typeparam name="TPixel">The destination pixel format.</typeparam>
-    /// <param name="brush">The brush used by a pending composition command.</param>
-    /// <returns>
-    /// <see langword="true"/> when the backend can compose the brush directly; otherwise <see langword="false"/>.
-    /// </returns>
-    public bool IsCompositionBrushSupported<TPixel>(Brush brush)
-        where TPixel : unmanaged, IPixel<TPixel>;
-
     /// <summary>
     /// Fills a path into a destination target region.
     /// </summary>