Remove WebGPUNativeSurfaceFactory

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WEBGPU_BACKEND.md

@@ -16,18 +16,14 @@ This document explains the backend as a newcomer would need to understand it:
 
 ## Where The Public WebGPU Types Fit
 
-The public WebGPU surface area around this backend is small and target-first. Most applications only reach for the recommended types; the advanced types exist as escape hatches for unusual interop scenarios.
+The public WebGPU surface area around this backend is small and target-first.
 
-**Recommended types** — the entry points most applications should use:
+**Public types** — the entry points applications should use:
 
 - `WebGPUEnvironment` exposes explicit support probes for the library-managed WebGPU environment
 - `WebGPUWindow` owns a native window and either runs a render loop or returns `WebGPUSurfaceFrame` instances through `TryAcquireFrame(...)`
 - `WebGPUExternalSurface` attaches to a caller-owned native host via `WebGPUSurfaceHost`; the host application owns the UI object and tells the external surface when the drawable framebuffer resizes
-- `WebGPURenderTarget` owns an offscreen native target for GPU rendering, hybrid CPU plus GPU canvases, and readback
-
-**Advanced types** — interop escape hatches for applications that already own a native texture target:
-
-- `WebGPUNativeSurfaceFactory` is the low-level escape hatch for caller-owned native targets
+- `WebGPURenderTarget` owns an offscreen native target for GPU rendering and readback
 
 `WebGPUDeviceContext` is internal infrastructure used by targets and surfaces. It is not part of the public WebGPU entry-point model.
 
@@ -149,7 +145,7 @@ The expensive staged work is delegated:
 The public object graph around those responsibilities is also separate:
 
 - `WebGPUEnvironment` handles explicit support probes
-- `WebGPUWindow`, `WebGPUExternalSurface`, and `WebGPURenderTarget` are the public target constructors; `WebGPUNativeSurfaceFactory` remains the low-level interop escape hatch for caller-owned textures
+- `WebGPUWindow`, `WebGPUExternalSurface`, and `WebGPURenderTarget` are the public target constructors
 - `DrawingCanvas` hands prepared `DrawingCommandBatch` ranges to the backend
 
 ## The Backend Boundary
@@ -269,7 +265,7 @@ The easiest way to keep this backend straight is to remember that it is not the
 If that model is clear, the major types fall into place:
 
 - `WebGPUEnvironment` exposes explicit support probes
-- `WebGPUWindow`, `WebGPUExternalSurface`, and `WebGPURenderTarget` are the recommended target types; `WebGPUNativeSurfaceFactory` is the advanced interop escape hatch
+- `WebGPUWindow`, `WebGPUExternalSurface`, and `WebGPURenderTarget` are the public target types
 - `WebGPUDrawingBackend` orchestrates and decides policy
 - `WebGPUFlushContext` owns one flush's execution state
 - `WebGPURuntime` owns longer-lived device state

src/ImageSharp.Drawing.WebGPU/WEBGPU_RASTERIZER.md

@@ -14,7 +14,7 @@ Together, these types turn one retained encoded scene into staged GPU work, sche
 
 This document starts after two earlier boundaries have already been crossed:
 
-- public WebGPU setup has already selected or created a native target through `WebGPUWindow`, `WebGPUExternalSurface`, `WebGPURenderTarget`, or `WebGPUNativeSurfaceFactory`
+- public WebGPU setup has already selected or created a native target through `WebGPUWindow`, `WebGPUExternalSurface`, or `WebGPURenderTarget`
 - `WebGPUDrawingBackend.RenderScene<TPixel>(...)` has already validated the typed native target
 
 Support probing through `WebGPUEnvironment` also sits outside this document. The rasterizer describes execution of one staged scene, not environment detection or object construction.

src/ImageSharp.Drawing.WebGPU/WebGPUDeviceContext.cs

@@ -271,7 +271,7 @@ private NativeSurface CreateSurface(
         Guard.NotNull(textureHandle, nameof(textureHandle));
         Guard.NotNull(textureViewHandle, nameof(textureViewHandle));
 
-        return WebGPUNativeSurfaceFactory.Create(
+        return WebGPUNativeSurface.Create(
             this.DeviceHandle,
             this.QueueHandle,
             textureHandle,

src/ImageSharp.Drawing.WebGPU/WebGPUNativeSurface.cs

@@ -17,6 +17,36 @@ internal sealed class WebGPUNativeSurface : NativeSurface
     internal WebGPUNativeSurface(WebGPUNativeTarget target)
         => this.target = target;
 
+    /// <summary>
+    /// Creates a native surface over wrapped WebGPU texture handles.
+    /// </summary>
+    internal static NativeSurface Create(
+        WebGPUDeviceHandle deviceHandle,
+        WebGPUQueueHandle queueHandle,
+        WebGPUTextureHandle targetTextureHandle,
+        WebGPUTextureViewHandle targetTextureViewHandle,
+        WebGPUTextureFormat targetFormat,
+        int width,
+        int height)
+    {
+        Guard.NotNull(deviceHandle, nameof(deviceHandle));
+        Guard.NotNull(queueHandle, nameof(queueHandle));
+        Guard.NotNull(targetTextureHandle, nameof(targetTextureHandle));
+        Guard.NotNull(targetTextureViewHandle, nameof(targetTextureViewHandle));
+
+        Guard.MustBeGreaterThan(width, 0, nameof(width));
+        Guard.MustBeGreaterThan(height, 0, nameof(height));
+
+        return new WebGPUNativeSurface(new WebGPUNativeTarget(
+            deviceHandle,
+            queueHandle,
+            targetTextureHandle,
+            targetTextureViewHandle,
+            targetFormat,
+            width,
+            height));
+    }
+
     /// <inheritdoc />
     public override TNativeTarget GetNativeTarget<TNativeTarget>()
         where TNativeTarget : class

src/ImageSharp.Drawing.WebGPU/WebGPUNativeSurfaceFactory.cs

@@ -121,7 +121,7 @@ private WebGPURenderTarget(
     /// Gets the native surface backing this render target.
     /// Most callers should use <see cref="CreateCanvas()"/> or <see cref="Readback{TPixel}"/> instead.
     /// </summary>
-    public NativeSurface Surface { get; }
+    internal NativeSurface Surface { get; }
 
     /// <summary>
     /// Gets the target width in pixels.

src/ImageSharp.Drawing.WebGPU/WebGPURenderTarget.cs

@@ -96,7 +96,7 @@ internal static NativeSurface CreateRenderTarget(
         {
             createdTextureHandle = new WebGPUTextureHandle(api, (nint)texture, ownsHandle: true);
             createdTextureViewHandle = new WebGPUTextureViewHandle(api, (nint)textureView, ownsHandle: true);
-            NativeSurface surface = WebGPUNativeSurfaceFactory.Create(
+            NativeSurface surface = WebGPUNativeSurface.Create(
                 deviceHandle,
                 queueHandle,
                 createdTextureHandle,