simplify CompositePixelRegistration storage and related lookup methods

Author: antonfirsov

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

@@ -16,7 +16,6 @@ internal static class FineAreaComputeShader
     private const string OutputStoreMarker = "textureStore(output, vec2<i32>(coords), rgba_sep);";
     private const string PremulAlphaMarker = "fn premul_alpha(rgba: vec4<f32>) -> vec4<f32> {";
 
-    private static readonly object CacheSync = new();
     private static readonly Dictionary<TextureFormat, byte[]> ShaderCache = [];
 
     /// <summary>
@@ -36,7 +35,7 @@ public static bool TryGetCode(TextureFormat textureFormat, out byte[] code, out
             return false;
         }
 
-        lock (CacheSync)
+        lock (ShaderCache)
         {
             if (ShaderCache.TryGetValue(textureFormat, out byte[]? cachedCode))
             {

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

@@ -11,19 +11,20 @@ namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 /// Pixel-format registration for composite session I/O.
 /// </summary>
 /// <remarks>
-/// The map defined by <see cref="CreateCompositePixelHandlers"/> is intentionally explicit and only
-/// includes one-to-one format mappings where the GPU texture format can round-trip the pixel payload
-/// without channel swizzle or custom conversion logic.
-/// Only formats that support <c>storage</c> texture binding (required by the compute compositor)
-/// are included. Formats that lack storage support are omitted and fall back to the CPU backend.
+/// <see cref="CompositeRegistrations"/> is intentionally explicit and only includes one-to-one format mappings
+/// where the GPU texture format can round-trip the pixel payload without channel swizzle or custom conversion logic.
+/// Only formats that support <c>storage</c> texture binding (required by the compute compositor) are included.
+/// Formats that lack storage support are omitted and fall back to the CPU backend.
 /// </remarks>
 public sealed partial class WebGPUDrawingBackend
 {
-    private static readonly Lazy<Dictionary<TextureFormat, TextureSampleType>> CompositeTextureSampleTypes =
-        new(CreateCompositeTextureSampleTypes);
-
-    private static readonly Lazy<Dictionary<TextureFormat, CompositeTextureShaderTraits>> CompositeTextureShaderTraitsMap =
-        new(CreateCompositeTextureShaderTraits);
+    private static readonly CompositePixelRegistration[] CompositeRegistrations =
+    [
+        CompositePixelRegistration.Create<NormalizedByte4>(TextureFormat.Rgba8Snorm, TextureSampleType.Float, new("rgba8snorm", CompositeTextureEncodingKind.Snorm)),
+        CompositePixelRegistration.Create<HalfVector4>(TextureFormat.Rgba16float, TextureSampleType.Float, new("rgba16float", CompositeTextureEncodingKind.Float)),
+        CompositePixelRegistration.Create<Rgba32>(TextureFormat.Rgba8Unorm, TextureSampleType.Float, new("rgba8unorm", CompositeTextureEncodingKind.Float)),
+        CompositePixelRegistration.Create<Bgra32>(TextureFormat.Bgra8Unorm, TextureSampleType.Float, new("bgra8unorm", CompositeTextureEncodingKind.Float), FeatureName.Bgra8UnormStorage),
+    ];
 
     /// <summary>
     /// Describes how one registered composite texture format encodes channel values in shader space.
@@ -37,37 +38,34 @@ internal enum CompositeTextureEncodingKind
         Sint16
     }
 
-    /// <summary>
-    /// Builds the static registration table that maps <see cref="IPixel{TSelf}"/> implementations to
-    /// compatible WebGPU storage/sampling formats.
-    /// </summary>
-    /// <returns>The registration map used during flush dispatch.</returns>
-    private static Dictionary<Type, CompositePixelRegistration> CreateCompositePixelHandlers() =>
-
-        // Only formats with native or feature-gated storage binding support.
-        new()
+    private static bool TryFind(Type pixelType, out CompositePixelRegistration registration)
+    {
+        foreach (CompositePixelRegistration r in CompositeRegistrations)
         {
-            [typeof(NormalizedByte4)] = CompositePixelRegistration.Create<NormalizedByte4>(TextureFormat.Rgba8Snorm, TextureSampleType.Float),
-
-            [typeof(HalfVector4)] = CompositePixelRegistration.Create<HalfVector4>(TextureFormat.Rgba16float, TextureSampleType.Float),
+            if (r.PixelType == pixelType)
+            {
+                registration = r;
+                return true;
+            }
+        }
 
-            [typeof(Rgba32)] = CompositePixelRegistration.Create<Rgba32>(TextureFormat.Rgba8Unorm, TextureSampleType.Float),
-            [typeof(Bgra32)] = CompositePixelRegistration.Create<Bgra32>(TextureFormat.Bgra8Unorm, TextureSampleType.Float, FeatureName.Bgra8UnormStorage)
-        };
+        registration = default;
+        return false;
+    }
 
-    /// <summary>
-    /// Builds the sampled-texture-type lookup keyed by the explicit composite format registrations.
-    /// </summary>
-    /// <returns>The lookup used by shader/bind-group setup.</returns>
-    private static Dictionary<TextureFormat, TextureSampleType> CreateCompositeTextureSampleTypes()
+    private static bool TryFind(TextureFormat textureFormat, out CompositePixelRegistration registration)
     {
-        Dictionary<TextureFormat, TextureSampleType> sampleTypes = [];
-        foreach (CompositePixelRegistration registration in CompositePixelHandlers.Values)
+        foreach (CompositePixelRegistration r in CompositeRegistrations)
         {
-            sampleTypes[registration.TextureFormat] = registration.SampleType;
+            if (r.TextureFormat == textureFormat)
+            {
+                registration = r;
+                return true;
+            }
         }
 
-        return sampleTypes;
+        registration = default;
+        return false;
     }
 
     /// <summary>
@@ -82,13 +80,13 @@ private static Dictionary<TextureFormat, TextureSampleType> CreateCompositeTextu
     internal static bool TryGetCompositeTextureFormat<TPixel>(out WebGPUTextureFormatId formatId)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        if (!CompositePixelHandlers.TryGetValue(typeof(TPixel), out CompositePixelRegistration registration))
+        if (!TryFind(typeof(TPixel), out CompositePixelRegistration r))
         {
             formatId = default;
             return false;
         }
 
-        formatId = WebGPUTextureFormatMapper.FromSilk(registration.TextureFormat);
+        formatId = WebGPUTextureFormatMapper.FromSilk(r.TextureFormat);
         return true;
     }
 
@@ -109,96 +107,66 @@ internal static bool TryGetCompositeTextureFormat<TPixel>(out WebGPUTextureForma
     internal static bool TryGetCompositeTextureFormat<TPixel>(out WebGPUTextureFormatId formatId, out FeatureName requiredFeature)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        if (!CompositePixelHandlers.TryGetValue(typeof(TPixel), out CompositePixelRegistration registration))
+        if (!TryFind(typeof(TPixel), out CompositePixelRegistration r))
         {
             formatId = default;
             requiredFeature = FeatureName.Undefined;
             return false;
         }
 
-        formatId = WebGPUTextureFormatMapper.FromSilk(registration.TextureFormat);
-        requiredFeature = registration.RequiredFeature;
+        formatId = WebGPUTextureFormatMapper.FromSilk(r.TextureFormat);
+        requiredFeature = r.RequiredFeature;
         return true;
     }
 
     /// <summary>
-    /// Resolves the unmanaged size in bytes of a registered composite pixel type.
+    /// Resolves the sampled texture type for a registered composite texture format.
     /// </summary>
-    /// <typeparam name="TPixel">The requested pixel type.</typeparam>
-    /// <param name="pixelSizeInBytes">Receives the unmanaged pixel size in bytes on success.</param>
+    /// <param name="textureFormat">The WebGPU texture format.</param>
+    /// <param name="sampleType">Receives the sampled texture type on success.</param>
     /// <returns>
-    /// <see langword="true"/> when the pixel type has a registered GPU format mapping; otherwise <see langword="false"/>.
+    /// <see langword="true"/> when the format is one of the explicitly registered composite formats;
+    /// otherwise <see langword="false"/>.
     /// </returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal static bool TryGetCompositePixelSize<TPixel>(out int pixelSizeInBytes)
-        where TPixel : unmanaged, IPixel<TPixel>
+    internal static bool TryGetCompositeTextureSampleType(TextureFormat textureFormat, out TextureSampleType sampleType)
     {
-        if (!CompositePixelHandlers.TryGetValue(typeof(TPixel), out CompositePixelRegistration registration))
+        if (!TryFind(textureFormat, out CompositePixelRegistration r))
         {
-            pixelSizeInBytes = 0;
+            sampleType = default;
             return false;
         }
 
-        pixelSizeInBytes = registration.PixelSizeInBytes;
+        sampleType = r.SampleType;
         return true;
     }
 
-    /// <summary>
-    /// Resolves the sampled texture type for a registered composite texture format.
-    /// </summary>
-    /// <param name="textureFormat">The WebGPU texture format.</param>
-    /// <param name="sampleType">Receives the sampled texture type on success.</param>
-    /// <returns>
-    /// <see langword="true"/> when the format is one of the explicitly registered composite formats;
-    /// otherwise <see langword="false"/>.
-    /// </returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    internal static bool TryGetCompositeTextureSampleType(TextureFormat textureFormat, out TextureSampleType sampleType)
-        => CompositeTextureSampleTypes.Value.TryGetValue(textureFormat, out sampleType);
-
     /// <summary>
     /// Resolves the shader-side read/write traits for a registered composite texture format.
     /// </summary>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static bool TryGetCompositeTextureShaderTraits(TextureFormat textureFormat, out CompositeTextureShaderTraits traits)
-        => CompositeTextureShaderTraitsMap.Value.TryGetValue(textureFormat, out traits);
-
-    /// <summary>
-    /// Builds the format-to-shader-traits lookup used when specializing composition shaders.
-    /// </summary>
-    private static Dictionary<TextureFormat, CompositeTextureShaderTraits> CreateCompositeTextureShaderTraits()
-        => new()
+    {
+        if (!TryFind(textureFormat, out CompositePixelRegistration r))
         {
-            [TextureFormat.Rgba8Snorm] = new CompositeTextureShaderTraits("rgba8snorm", "f32", TextureSampleType.Float, CompositeTextureEncodingKind.Snorm),
-            [TextureFormat.Rgba16float] = new CompositeTextureShaderTraits("rgba16float", "f32", TextureSampleType.Float, CompositeTextureEncodingKind.Float),
-            [TextureFormat.Rgba8Unorm] = new CompositeTextureShaderTraits("rgba8unorm", "f32", TextureSampleType.Float, CompositeTextureEncodingKind.Float),
-            [TextureFormat.Bgra8Unorm] = new CompositeTextureShaderTraits("bgra8unorm", "f32", TextureSampleType.Float, CompositeTextureEncodingKind.Float)
-        };
+            traits = default;
+            return false;
+        }
+
+        traits = r.ShaderTraits;
+        return true;
+    }
 
     /// <summary>
     /// Shader-facing traits derived from one registered composite texture format.
     /// </summary>
-    internal readonly struct CompositeTextureShaderTraits(
-        string outputFormat,
-        string texelType,
-        TextureSampleType sampleType,
-        CompositeTextureEncodingKind encodingKind)
+    internal readonly struct CompositeTextureShaderTraits(string outputFormat, CompositeTextureEncodingKind encodingKind)
     {
         /// <summary>
         /// Gets the WGSL storage-texture format token used for writes.
         /// </summary>
         public string OutputFormat { get; } = outputFormat;
 
-        /// <summary>
-        /// Gets the WGSL sampled texel type used when reading the texture.
-        /// </summary>
-        public string TexelType { get; } = texelType;
-
-        /// <summary>
-        /// Gets the WebGPU sampled texture type required by bind-group validation.
-        /// </summary>
-        public TextureSampleType SampleType { get; } = sampleType;
-
         /// <summary>
         /// Gets the numeric encoding that the shader must apply when storing output texels.
         /// </summary>
@@ -218,18 +186,19 @@ private readonly struct CompositePixelRegistration
         /// <param name="sampleType">The sampled texture type for this format.</param>
         /// <param name="pixelSizeInBytes">The unmanaged pixel size in bytes.</param>
         /// <param name="requiredFeature">Optional device feature required for storage binding support.</param>
+        /// <param name="shaderTraits">Shader-facing read/write traits for this format.</param>
         public CompositePixelRegistration(
             Type pixelType,
             TextureFormat textureFormat,
             TextureSampleType sampleType,
-            int pixelSizeInBytes,
-            FeatureName requiredFeature)
+            FeatureName requiredFeature,
+            CompositeTextureShaderTraits shaderTraits)
         {
             this.PixelType = pixelType;
             this.TextureFormat = textureFormat;
             this.SampleType = sampleType;
-            this.PixelSizeInBytes = pixelSizeInBytes;
             this.RequiredFeature = requiredFeature;
+            this.ShaderTraits = shaderTraits;
         }
 
         /// <summary>
@@ -242,11 +211,6 @@ public CompositePixelRegistration(
         /// </summary>
         public TextureFormat TextureFormat { get; }
 
-        /// <summary>
-        /// Gets the unmanaged size of the pixel type in bytes.
-        /// </summary>
-        public int PixelSizeInBytes { get; }
-
         /// <summary>
         /// Gets the sampled texture type used when reading this format.
         /// </summary>
@@ -259,26 +223,21 @@ public CompositePixelRegistration(
         public FeatureName RequiredFeature { get; }
 
         /// <summary>
-        /// Creates a registration record for <typeparamref name="TPixel"/> with native storage support.
+        /// Gets the shader-facing read/write traits for this format.
         /// </summary>
-        /// <param name="textureFormat">The matching WebGPU texture format.</param>
-        /// <param name="sampleType">The sampled texture type for this format.</param>
-        /// <returns>The initialized registration.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static CompositePixelRegistration Create<TPixel>(TextureFormat textureFormat, TextureSampleType sampleType)
-            where TPixel : unmanaged, IPixel<TPixel>
-            => new(typeof(TPixel), textureFormat, sampleType, Unsafe.SizeOf<TPixel>(), FeatureName.Undefined);
+        public CompositeTextureShaderTraits ShaderTraits { get; }
 
         /// <summary>
         /// Creates a registration record for <typeparamref name="TPixel"/> with a required device feature.
         /// </summary>
         /// <param name="textureFormat">The matching WebGPU texture format.</param>
         /// <param name="sampleType">The sampled texture type for this format.</param>
+        /// <param name="shaderTraits">Shader-facing read/write traits for this format.</param>
         /// <param name="requiredFeature">The device feature required for storage binding.</param>
         /// <returns>The initialized registration.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static CompositePixelRegistration Create<TPixel>(TextureFormat textureFormat, TextureSampleType sampleType, FeatureName requiredFeature)
+        public static CompositePixelRegistration Create<TPixel>(TextureFormat textureFormat, TextureSampleType sampleType, CompositeTextureShaderTraits shaderTraits, FeatureName requiredFeature = FeatureName.Undefined)
             where TPixel : unmanaged, IPixel<TPixel>
-            => new(typeof(TPixel), textureFormat, sampleType, Unsafe.SizeOf<TPixel>(), requiredFeature);
+            => new(typeof(TPixel), textureFormat, sampleType, requiredFeature, shaderTraits);
     }
 }

src/ImageSharp.Drawing.WebGPU/WebGPUDrawingBackend.cs

@@ -43,8 +43,6 @@ public sealed unsafe partial class WebGPUDrawingBackend : IDrawingBackend, IDisp
     private WebGPUSceneDispatch.BindingLimitBuffer lastChunkingBindingFailure;
     private bool isDisposed;
 
-    private static readonly Dictionary<Type, CompositePixelRegistration> CompositePixelHandlers = CreateCompositePixelHandlers();
-
     /// <summary>
     /// Initializes a new instance of the <see cref="WebGPUDrawingBackend"/> class.
     /// </summary>