Make NativeSurface abstract, simplify, and add WebGPU surface

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUNativeSurface.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
+
+/// <summary>
+/// WebGPU native drawing target exposed through the backend-agnostic <see cref="NativeSurface"/> contract.
+/// </summary>
+internal sealed class WebGPUNativeSurface : NativeSurface
+{
+    private readonly WebGPUSurfaceCapability capability;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WebGPUNativeSurface"/> class.
+    /// </summary>
+    /// <param name="capability">The WebGPU capability exposed by this surface.</param>
+    internal WebGPUNativeSurface(WebGPUSurfaceCapability capability)
+        => this.capability = capability;
+
+    /// <inheritdoc />
+    public override bool TryGetCapability<TCapability>([NotNullWhen(true)] out TCapability? capability)
+        where TCapability : class
+    {
+        if (this.capability is TCapability typed)
+        {
+            capability = typed;
+            return true;
+        }
+
+        capability = null;
+        return false;
+    }
+}

src/ImageSharp.Drawing.WebGPU/WebGPUNativeSurfaceFactory.cs

@@ -69,16 +69,14 @@ internal static NativeSurface Create<TPixel>(
         Guard.MustBeGreaterThan(height, 0, nameof(height));
         ValidatePixelCompatibility<TPixel>(targetFormat);
 
-        NativeSurface nativeSurface = new(TPixel.GetPixelTypeInfo());
-        nativeSurface.SetCapability(new WebGPUSurfaceCapability(
+        return new WebGPUNativeSurface(new WebGPUSurfaceCapability(
             deviceHandle,
             queueHandle,
             targetTextureHandle,
             targetTextureViewHandle,
             targetFormat,
             width,
             height));
-        return nativeSurface;
     }
 
     /// <summary>

src/ImageSharp.Drawing.WebGPU/WebGPUSurfaceCapability.cs

@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 
 /// <summary>
-/// Native WebGPU surface capability attached to <see cref="NativeSurface"/>.
+/// Native WebGPU surface capability exposed by a <see cref="NativeSurface"/>.
 /// </summary>
 /// <remarks>
 /// The backing WebGPU device, queue, texture, and texture view must remain valid while canvases target this surface.

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

@@ -1,40 +1,20 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
 
 namespace SixLabors.ImageSharp.Drawing.Processing.Backends;
 
 /// <summary>
 /// Represents a backend-specific native drawing target.
 /// </summary>
-public sealed class NativeSurface
+public abstract class NativeSurface
 {
-    private readonly ConcurrentDictionary<Type, object> capabilities = new();
-
     /// <summary>
     /// Initializes a new instance of the <see cref="NativeSurface"/> class.
     /// </summary>
-    /// <param name="pixelType">Pixel format information for the destination surface.</param>
-    public NativeSurface(PixelTypeInfo pixelType)
-        => this.PixelType = pixelType;
-
-    /// <summary>
-    /// Gets pixel format information for this destination surface.
-    /// </summary>
-    public PixelTypeInfo PixelType { get; }
-
-    /// <summary>
-    /// Associates a backend capability with this surface.
-    /// </summary>
-    /// <typeparam name="TCapability">Capability type.</typeparam>
-    /// <param name="capability">Capability instance.</param>
-    public void SetCapability<TCapability>(TCapability capability)
-        where TCapability : class
+    protected NativeSurface()
     {
-        Guard.NotNull(capability, nameof(capability));
-        this.capabilities[typeof(TCapability)] = capability;
     }
 
     /// <summary>
@@ -43,16 +23,6 @@ public void SetCapability<TCapability>(TCapability capability)
     /// <typeparam name="TCapability">Capability type.</typeparam>
     /// <param name="capability">Capability instance when available.</param>
     /// <returns><see langword="true"/> when found.</returns>
-    public bool TryGetCapability<TCapability>([NotNullWhen(true)] out TCapability? capability)
-        where TCapability : class
-    {
-        if (this.capabilities.TryGetValue(typeof(TCapability), out object? value) && value is TCapability typed)
-        {
-            capability = typed;
-            return true;
-        }
-
-        capability = null;
-        return false;
-    }
+    public abstract bool TryGetCapability<TCapability>([NotNullWhen(true)] out TCapability? capability)
+        where TCapability : class;
 }

tests/ImageSharp.Drawing.Tests/Processing/DrawingCanvasTests.Process.cs

@@ -74,7 +74,7 @@ public void Process_NoCpuFrame_WithReadbackCapability_MatchesReference<TPixel>(T
         MemoryCanvasFrame<TPixel> proxyFrame = new(new Buffer2DRegion<TPixel>(target.Frames.RootFrame.PixelBuffer));
         MirroringCpuReadbackTestBackend<TPixel> mirroringBackend = new(proxyFrame, target);
 
-        NativeSurface nativeSurface = new(TPixel.GetPixelTypeInfo());
+        NativeSurface nativeSurface = new NoCapabilityNativeSurface();
         Configuration configuration = provider.Configuration.Clone();
         configuration.SetDrawingBackend(mirroringBackend);
 
@@ -158,6 +158,16 @@ private static IPath CreatePixelateTrianglePath()
         return pathBuilder.Build();
     }
 
+    private sealed class NoCapabilityNativeSurface : NativeSurface
+    {
+        public override bool TryGetCapability<TCapability>(out TCapability capability)
+            where TCapability : class
+        {
+            capability = null!;
+            return false;
+        }
+    }
+
     /// <summary>
     /// Test backend that mirrors composition output into a CPU frame and optionally serves readback
     /// from a backing image for process-path tests.