Add aliased fine-pass threshold shader and plumbing

JimBobSquarePants · JimBobSquarePants · commit bd8d170e5860 · 2026-03-25T10:45:13.000+10:00
diff --git a/src/ImageSharp.Drawing.WebGPU/Shaders/FineAliasedThresholdComputeShader.cs b/src/ImageSharp.Drawing.WebGPU/Shaders/FineAliasedThresholdComputeShader.cs
@@ -0,0 +1,195 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Text;
+using Silk.NET.WebGPU;
+
+namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
+
+/// <summary>
+/// Final staged-scene fine pass for thresholded aliased rasterization.
+/// The WGSL stays shared with the analytic fine pass, but coverage is quantized
+/// immediately after path evaluation so brush evaluation and composition still
+/// reuse the same scene encoding and blend logic.
+/// </summary>
+internal static class FineAliasedThresholdComputeShader
+{
+    private const string OutputBindingMarker = "var output: texture_storage_2d<rgba8unorm, write>;";
+    private const string OutputStoreMarker = "textureStore(output, vec2<i32>(coords), rgba_sep);";
+    private const string PremulAlphaMarker = "fn premul_alpha(rgba: vec4<f32>) -> vec4<f32> {";
+    private const string WorkgroupSizeMarker = "// The X size should be 16 / PIXELS_PER_THREAD";
+    private const string AnalyticFillCallMarker = "                fill_path(fill, local_xy, &area);";
+    private const string MsaaFillCallMarker = "                fill_path_ms(fill, local_id.xy, &area);";
+    private const string ThresholdHelper =
+        """
+        fn apply_aliased_threshold(result: ptr<function, array<f32, PIXELS_PER_THREAD>>) {
+            let threshold = config.fine_coverage_threshold;
+            for (var i = 0u; i < PIXELS_PER_THREAD; i += 1u) {
+                (*result)[i] = select(0.0, 1.0, (*result)[i] >= threshold);
+            }
+        }
+
+        """;
+
+    private static readonly object CacheSync = new();
+    private static readonly Dictionary<TextureFormat, byte[]> ShaderCache = [];
+
+    /// <summary>
+    /// Gets the compute entry point exported by the aliased fine shader.
+    /// </summary>
+    public static ReadOnlySpan<byte> EntryPoint => "main\0"u8;
+
+    /// <summary>
+    /// Gets the texture-format-specialized WGSL for the aliased threshold fine pass.
+    /// </summary>
+    public static bool TryGetCode(TextureFormat textureFormat, out byte[] code, out string? error)
+    {
+        if (!TryGetTraits(textureFormat, out ShaderTraits traits))
+        {
+            code = [];
+            error = $"Scene aliased-threshold fine shader does not support texture format '{textureFormat}'.";
+            return false;
+        }
+
+        lock (CacheSync)
+        {
+            if (ShaderCache.TryGetValue(textureFormat, out byte[]? cachedCode))
+            {
+                code = cachedCode;
+                error = null;
+                return true;
+            }
+
+            string source = GeneratedWgslShaderSources.FineText;
+            source = source.Replace(OutputBindingMarker, $"var output: texture_storage_2d<{traits.OutputFormat}, write>;", StringComparison.Ordinal);
+            source = source.Replace(OutputStoreMarker, traits.StoreOutputStatement, StringComparison.Ordinal);
+            source = source.Replace(PremulAlphaMarker, $"{traits.EncodeOutputFunction}\n\n{PremulAlphaMarker}", StringComparison.Ordinal);
+            source = source.Replace(WorkgroupSizeMarker, $"{ThresholdHelper}{WorkgroupSizeMarker}", StringComparison.Ordinal);
+            source = source.Replace(AnalyticFillCallMarker, $"{AnalyticFillCallMarker}\n                apply_aliased_threshold(&area);", StringComparison.Ordinal);
+            source = source.Replace(MsaaFillCallMarker, $"{MsaaFillCallMarker}\n                apply_aliased_threshold(&area);", StringComparison.Ordinal);
+
+            int byteCount = Encoding.UTF8.GetByteCount(source);
+            code = new byte[byteCount + 1];
+            _ = Encoding.UTF8.GetBytes(source, code);
+            code[^1] = 0;
+            ShaderCache[textureFormat] = code;
+        }
+
+        error = null;
+        return true;
+    }
+
+    /// <summary>
+    /// Creates the bind-group layout consumed by the aliased threshold fine pass.
+    /// </summary>
+    public static unsafe bool TryCreateBindGroupLayout(
+        WebGPU api,
+        Device* device,
+        TextureFormat outputTextureFormat,
+        out BindGroupLayout* layout,
+        out string? error)
+        => FineAreaComputeShader.TryCreateBindGroupLayout(api, device, outputTextureFormat, out layout, out error);
+
+    private static bool TryGetTraits(TextureFormat textureFormat, out ShaderTraits traits)
+    {
+        if (!WebGPUDrawingBackend.TryGetCompositeTextureShaderTraits(textureFormat, out WebGPUDrawingBackend.CompositeTextureShaderTraits compositeTraits))
+        {
+            traits = default;
+            return false;
+        }
+
+        traits = compositeTraits.EncodingKind switch
+        {
+            WebGPUDrawingBackend.CompositeTextureEncodingKind.Float => CreateFloatTraits(compositeTraits.OutputFormat),
+            WebGPUDrawingBackend.CompositeTextureEncodingKind.Snorm => CreateSnormTraits(compositeTraits.OutputFormat),
+            WebGPUDrawingBackend.CompositeTextureEncodingKind.Uint8 => CreateUintTraits(compositeTraits.OutputFormat, 255F),
+            WebGPUDrawingBackend.CompositeTextureEncodingKind.Uint16 => CreateUintTraits(compositeTraits.OutputFormat, 65535F),
+            WebGPUDrawingBackend.CompositeTextureEncodingKind.Sint16 => CreateSintTraits(compositeTraits.OutputFormat, -32768F, 32767F),
+            _ => default
+        };
+
+        return true;
+    }
+
+    private static ShaderTraits CreateFloatTraits(string outputFormat)
+    {
+        const string encodeOutput =
+            """
+            fn encode_output(color: vec4<f32>) -> vec4<f32> {
+                return color;
+            }
+            """;
+
+        return new ShaderTraits(
+            outputFormat,
+            encodeOutput,
+            "textureStore(output, vec2<i32>(coords), encode_output(rgba_sep));");
+    }
+
+    private static ShaderTraits CreateSnormTraits(string outputFormat)
+    {
+        const string encodeOutput =
+            """
+            fn encode_output(color: vec4<f32>) -> vec4<f32> {
+                let clamped = clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));
+                return (clamped * 2.0) - vec4<f32>(1.0);
+            }
+            """;
+
+        return new ShaderTraits(
+            outputFormat,
+            encodeOutput,
+            "textureStore(output, vec2<i32>(coords), encode_output(rgba_sep));");
+    }
+
+    private static ShaderTraits CreateUintTraits(string outputFormat, float maxValue)
+    {
+        string maxVector = $"vec4<f32>({maxValue:F1}, {maxValue:F1}, {maxValue:F1}, {maxValue:F1})";
+        const string encodeOutput =
+            """
+            const UINT_TEXEL_MAX: vec4<f32> = __UINT_TEXEL_MAX__;
+            fn encode_output(color: vec4<f32>) -> vec4<u32> {
+                let clamped = clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));
+                return vec4<u32>(round(clamped * UINT_TEXEL_MAX));
+            }
+            """;
+
+        return new ShaderTraits(
+            outputFormat,
+            encodeOutput.Replace("__UINT_TEXEL_MAX__", maxVector, StringComparison.Ordinal),
+            "textureStore(output, vec2<i32>(coords), encode_output(rgba_sep));");
+    }
+
+    private static ShaderTraits CreateSintTraits(string outputFormat, float minValue, float maxValue)
+    {
+        string minVector = $"vec4<f32>({minValue:F1}, {minValue:F1}, {minValue:F1}, {minValue:F1})";
+        string maxVector = $"vec4<f32>({maxValue:F1}, {maxValue:F1}, {maxValue:F1}, {maxValue:F1})";
+        string encodeOutput =
+            $$"""
+            const SINT_TEXEL_MIN: vec4<f32> = {{minVector}};
+            const SINT_TEXEL_MAX: vec4<f32> = {{maxVector}};
+            const SINT_TEXEL_RANGE: vec4<f32> = SINT_TEXEL_MAX - SINT_TEXEL_MIN;
+            fn encode_output(color: vec4<f32>) -> vec4<i32> {
+                let clamped = clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));
+                return vec4<i32>(round((clamped * SINT_TEXEL_RANGE) + SINT_TEXEL_MIN));
+            }
+            """;
+
+        return new ShaderTraits(
+            outputFormat,
+            encodeOutput,
+            "textureStore(output, vec2<i32>(coords), encode_output(rgba_sep));");
+    }
+
+    private readonly struct ShaderTraits(
+        string outputFormat,
+        string encodeOutputFunction,
+        string storeOutputStatement)
+    {
+        public string OutputFormat { get; } = outputFormat;
+
+        public string EncodeOutputFunction { get; } = encodeOutputFunction;
+
+        public string StoreOutputStatement { get; } = storeOutputStatement;
+    }
+}
diff --git a/src/ImageSharp.Drawing.WebGPU/Shaders/Shared/config.wgsl b/src/ImageSharp.Drawing.WebGPU/Shaders/Shared/config.wgsl
@@ -39,6 +39,7 @@ struct Config {
     segments_size: u32,
     blend_size: u32,
     ptcl_size: u32,
+    fine_coverage_threshold: f32,
 }
 
 // Geometry of tiles and bins
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUSceneDispatch.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUSceneDispatch.cs
@@ -40,6 +40,7 @@ internal static class WebGPUSceneDispatch
     private const string PathTilingSetupPipelineKey = "scene/path-tiling-setup";
     private const string PathTilingPipelineKey = "scene/path-tiling";
     private const string FineAreaPipelineKey = "scene/fine-area";
+    private const string FineAliasedThresholdPipelineKey = "scene/fine-aliased-threshold";
 
     /// <summary>
     /// Builds the flush-scoped encoded scene and uploads its GPU resources.
@@ -1192,23 +1193,39 @@ private static unsafe bool TryDispatchFineArea(
         uint groupCountY,
         out string? error)
     {
-        if (!FineAreaComputeShader.TryGetCode(flushContext.TextureFormat, out byte[] shaderCode, out error))
+        bool useAliasedThreshold = encodedScene.FineRasterizationMode == RasterizationMode.Aliased;
+        byte[] shaderCode;
+        if (useAliasedThreshold)
+        {
+            if (!FineAliasedThresholdComputeShader.TryGetCode(flushContext.TextureFormat, out shaderCode, out error))
+            {
+                return false;
+            }
+        }
+        else if (!FineAreaComputeShader.TryGetCode(flushContext.TextureFormat, out shaderCode, out error))
         {
             return false;
         }
 
         bool LayoutFactory(WebGPU api, Device* device, out BindGroupLayout* layout, out string? layoutError)
-            => FineAreaComputeShader.TryCreateBindGroupLayout(
-                api,
-                device,
-                flushContext.TextureFormat,
-                out layout,
-                out layoutError);
+            => useAliasedThreshold
+                ? FineAliasedThresholdComputeShader.TryCreateBindGroupLayout(
+                    api,
+                    device,
+                    flushContext.TextureFormat,
+                    out layout,
+                    out layoutError)
+                : FineAreaComputeShader.TryCreateBindGroupLayout(
+                    api,
+                    device,
+                    flushContext.TextureFormat,
+                    out layout,
+                    out layoutError);
 
         if (!flushContext.DeviceState.TryGetOrCreateCompositeComputePipeline(
-                $"{FineAreaPipelineKey}/{flushContext.TextureFormat}",
+                $"{(useAliasedThreshold ? FineAliasedThresholdPipelineKey : FineAreaPipelineKey)}/{flushContext.TextureFormat}",
                 shaderCode,
-                FineAreaComputeShader.EntryPoint,
+                useAliasedThreshold ? FineAliasedThresholdComputeShader.EntryPoint : FineAreaComputeShader.EntryPoint,
                 LayoutFactory,
                 out BindGroupLayout* bindGroupLayout,
                 out ComputePipeline* pipeline,
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUSceneEncoder.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUSceneEncoder.cs
@@ -100,6 +100,7 @@ private ref struct SupportedSubsetSceneEncoding
         private bool gradientPixelsDetached;
         private uint lastStyle0;
         private uint lastStyle1;
+        private bool hasFineRasterizationMode;
         private readonly Rectangle rootTargetBounds;
         private List<Rectangle>? openLayerBounds;
 
@@ -130,8 +131,11 @@ private SupportedSubsetSceneEncoding(MemoryAllocator allocator, int commandCount
             this.gradientPixelsDetached = false;
             this.lastStyle0 = 0;
             this.lastStyle1 = 0;
+            this.hasFineRasterizationMode = false;
             this.rootTargetBounds = rootTargetBounds;
             this.openLayerBounds = null;
+            this.FineRasterizationMode = RasterizationMode.Antialiased;
+            this.FineCoverageThreshold = 0F;
 
             this.PathTags.Add(PathTagTransform);
             AppendIdentityTransform(ref this.Transforms);
@@ -212,6 +216,16 @@ private SupportedSubsetSceneEncoding(MemoryAllocator allocator, int commandCount
         /// </summary>
         public int GradientRowCount { get; private set; }
 
+        /// <summary>
+        /// Gets the flush-wide fine rasterization mode selected while encoding visible fills.
+        /// </summary>
+        public RasterizationMode FineRasterizationMode { get; private set; }
+
+        /// <summary>
+        /// Gets the aliased coverage threshold consumed by the fine pass when aliased mode is selected.
+        /// </summary>
+        public float FineCoverageThreshold { get; private set; }
+
         /// <summary>
         /// Gets a value indicating whether the encoding produced no fill work.
         /// </summary>
@@ -277,6 +291,14 @@ private void Append(in CompositionCommand command)
                         return;
                     }
 
+                    RasterizerOptions options = command.RasterizerOptions;
+                    if (!this.hasFineRasterizationMode)
+                    {
+                        this.hasFineRasterizationMode = true;
+                        this.FineRasterizationMode = options.RasterizationMode;
+                        this.FineCoverageThreshold = options.AntialiasThreshold;
+                    }
+
                     IPath preparedPath = command.PreparedPath!;
                     this.AppendPlainFill(command, preparedPath);
                     return;
@@ -515,7 +537,9 @@ public static WebGPUEncodedScene Resolve(
                     encoding.TotalTileMembershipCount,
                     0,
                     DivideRoundUp(targetBounds.Width, TileWidth),
-                    DivideRoundUp(targetBounds.Height, TileHeight));
+                    DivideRoundUp(targetBounds.Height, TileHeight),
+                    encoding.FineRasterizationMode,
+                    encoding.FineCoverageThreshold);
             }
             catch
             {
@@ -1308,7 +1332,9 @@ internal sealed class WebGPUEncodedScene : IDisposable
         0,
         0,
         0,
-        0);
+        0,
+        RasterizationMode.Antialiased,
+        0F);
 
     private readonly IMemoryOwner<uint>? sceneDataOwner;
     private readonly IMemoryOwner<uint>? gradientPixelsOwner;
@@ -1343,7 +1369,9 @@ public WebGPUEncodedScene(
         int totalTileMembershipCount,
         int totalLineSliceCount,
         int tileCountX,
-        int tileCountY)
+        int tileCountY,
+        RasterizationMode fineRasterizationMode,
+        float fineCoverageThreshold)
     {
         this.TargetSize = targetSize;
         this.InfoWordCount = infoWordCount;
@@ -1370,6 +1398,8 @@ public WebGPUEncodedScene(
         this.TotalLineSliceCount = totalLineSliceCount;
         this.TileCountX = tileCountX;
         this.TileCountY = tileCountY;
+        this.FineRasterizationMode = fineRasterizationMode;
+        this.FineCoverageThreshold = fineCoverageThreshold;
     }
 
     /// <summary>
@@ -1494,6 +1524,16 @@ public ReadOnlyMemory<uint> GradientPixels
     /// </summary>
     public int TileCountY { get; }
 
+    /// <summary>
+    /// Gets the fine-pass rasterization mode selected for this flush.
+    /// </summary>
+    public RasterizationMode FineRasterizationMode { get; }
+
+    /// <summary>
+    /// Gets the scene-wide aliased coverage threshold consumed by the fine pass.
+    /// </summary>
+    public float FineCoverageThreshold { get; }
+
     /// <summary>
     /// Gets the total tile count.
     /// </summary>
diff --git a/src/ImageSharp.Drawing.WebGPU/WebGPUSceneResources.cs b/src/ImageSharp.Drawing.WebGPU/WebGPUSceneResources.cs

Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,7 @@ struct Config {`
`39`	`39`	`segments_size: u32,`
`40`	`40`	`blend_size: u32,`
`41`	`41`	`ptcl_size: u32,`
	`42`	`+ fine_coverage_threshold: f32,`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`// Geometry of tiles and bins`