@aethervtt/shard-gpu 0.0.1 → 0.1.0

package/dist/surface.js

@@ -0,0 +1,110 @@
+class Surface {
+  label;
+  canvas;
+  alpha;
+  context;
+  /** Cameras showing on a surface render at the RenderScale and are upscaled (0051). */
+  renderScale = true;
+  /** Canvas pixels per CSS pixel (devicePixelRatio) at the last resize. */
+  pixelRatio = 1;
+  /** The device it's configured for. */
+  gpu;
+  observer;
+  resizeListeners = /* @__PURE__ */ new Set();
+  removed_ = false;
+  /** @internal Made by `GpuContext.addSurface`. */
+  constructor(gpu, canvas, context, options) {
+    this.gpu = gpu;
+    this.canvas = canvas;
+    this.context = context;
+    this.alpha = options.alpha;
+    this.label = options.label;
+    this.configure();
+    this.measure();
+    const Observer = globalThis.ResizeObserver;
+    if (Observer && isElement(canvas)) {
+      this.observer = new Observer((entries) => this.onObserved(entries));
+      try {
+        this.observer.observe(canvas, { box: "device-pixel-content-box" });
+      } catch {
+        this.observer.observe(canvas);
+      }
+    }
+  }
+  get format() {
+    return this.gpu.format;
+  }
+  get width() {
+    return this.canvas.width;
+  }
+  get height() {
+    return this.canvas.height;
+  }
+  /** True once `remove()` was called. */
+  get removed() {
+    return this.removed_;
+  }
+  /** The texture to render into this frame. */
+  texture() {
+    if (!this.observer) this.measure();
+    return this.context.getCurrentTexture();
+  }
+  /** Calls `listener` after the canvas's backing size changes. Returns an unsubscribe function. */
+  onResize(listener) {
+    this.resizeListeners.add(listener);
+    return () => this.resizeListeners.delete(listener);
+  }
+  /** Unconfigures the canvas, stops observing it, and takes it off the device. Idempotent. */
+  remove() {
+    if (this.removed_) return;
+    this.removed_ = true;
+    this.observer?.disconnect();
+    this.resizeListeners.clear();
+    this.context.unconfigure();
+    this.gpu.forgetSurface(this);
+  }
+  /** @internal Configures the canvas for the current device, keeping its alpha mode. */
+  configure() {
+    this.context.configure({
+      device: this.gpu.device,
+      format: this.gpu.format,
+      alphaMode: this.alpha,
+      // COPY_SRC lets the renderer capture screenshots straight from the swapchain.
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
+    });
+  }
+  /** Sizes the backing store from the element's CSS size (no-op for an OffscreenCanvas). */
+  measure() {
+    const canvas = this.canvas;
+    if (!isElement(canvas)) return;
+    const dpr = globalThis.devicePixelRatio ?? 1;
+    this.resize(canvas.clientWidth * dpr, canvas.clientHeight * dpr, dpr);
+  }
+  onObserved(entries) {
+    const entry = entries[entries.length - 1];
+    if (!entry || this.removed_) return;
+    const dpr = globalThis.devicePixelRatio ?? 1;
+    const box = entry.contentBoxSize?.[0];
+    const w = box ? box.inlineSize : entry.contentRect?.width;
+    const h = box ? box.blockSize : entry.contentRect?.height;
+    const exact = entry.devicePixelContentBoxSize?.[0];
+    if (exact) this.resize(exact.inlineSize, exact.blockSize, w ? exact.inlineSize / w : dpr);
+    else this.resize((w ?? 0) * dpr, (h ?? 0) * dpr, dpr);
+  }
+  resize(w, h, dpr) {
+    this.pixelRatio = dpr;
+    const width = Math.max(1, Math.floor(w));
+    const height = Math.max(1, Math.floor(h));
+    const canvas = this.canvas;
+    if (canvas.width === width && canvas.height === height) return;
+    canvas.width = width;
+    canvas.height = height;
+    for (const listener of this.resizeListeners) listener();
+  }
+}
+function isElement(canvas) {
+  return "clientWidth" in canvas;
+}
+export {
+  Surface
+};

package/dist/tier.d.ts

@@ -0,0 +1,41 @@
+export type GpuBackendName = 'webgpu' | 'webgl2';
+export type GpuTier = 'full' | 'baseline';
+/** What the device can do, as far as the tiers care. */
+export interface GpuCapabilities {
+    /** A WebGPU core device (`core-features-and-limits`). */
+    core: boolean;
+    compute: boolean;
+    storageBuffersPerStage: {
+        vertex: number;
+        fragment: number;
+        compute: number;
+    };
+    /** Any format or dimension view of any texture (core only). */
+    arbitraryTextureViews: boolean;
+    maxTextureDimension2D: number;
+    maxColorAttachments: number;
+    maxUniformBufferBindingSize: number;
+    /**
+     * The most samples an HDR scene target (`rgba16float`) takes: 4, or 1 where float targets can't
+     * multisample (some compatibility-mode devices and WebGL2 implementations).
+     */
+    hdrSampleCount: 1 | 4;
+}
+/** Why a better option was skipped: `{ backend: 'webgpu', code: 'no-adapter', … }`. */
+export interface GraphicsReason {
+    backend: GpuBackendName;
+    code: string;
+    message: string;
+}
+/**
+ * Whether a device follows core WebGPU's rules. Core devices carry `core-features-and-limits`;
+ * browsers from before compatibility mode know neither the feature nor its per-stage storage
+ * limits, and every device they make is core.
+ */
+export declare function isCoreDevice(device: GPUDevice): boolean;
+export declare function capabilitiesOf(device: GPUDevice, backend: GpuBackendName, hdrSampleCount?: 1 | 4): GpuCapabilities;
+/**
+ * Whether `rgba16float` targets multisample 4×: always on a core device (checked without asking
+ * it anything), else found by creating one in an error scope.
+ */
+export declare function probeHdrSampleCount(device: GPUDevice): Promise<1 | 4>;

package/dist/tier.js

@@ -0,0 +1,42 @@
+function isCoreDevice(device) {
+  if (device.features.has("core-features-and-limits")) return true;
+  return device.limits.maxStorageBuffersInVertexStage === void 0;
+}
+function capabilitiesOf(device, backend, hdrSampleCount = 4) {
+  const limits = device.limits;
+  const core = backend === "webgpu" && isCoreDevice(device);
+  const perStage = limits.maxStorageBuffersPerShaderStage;
+  return {
+    core,
+    compute: backend === "webgpu",
+    storageBuffersPerStage: {
+      vertex: backend === "webgl2" ? 0 : limits.maxStorageBuffersInVertexStage ?? perStage,
+      fragment: backend === "webgl2" ? 0 : limits.maxStorageBuffersInFragmentStage ?? perStage,
+      compute: backend === "webgl2" ? 0 : perStage
+    },
+    arbitraryTextureViews: core,
+    maxTextureDimension2D: limits.maxTextureDimension2D,
+    maxColorAttachments: limits.maxColorAttachments,
+    maxUniformBufferBindingSize: limits.maxUniformBufferBindingSize,
+    hdrSampleCount
+  };
+}
+async function probeHdrSampleCount(device) {
+  if (isCoreDevice(device)) return 4;
+  device.pushErrorScope("validation");
+  const texture = device.createTexture({
+    label: "shard/msaa-probe",
+    size: [1, 1],
+    format: "rgba16float",
+    sampleCount: 4,
+    usage: GPUTextureUsage.RENDER_ATTACHMENT
+  });
+  const error = await device.popErrorScope();
+  texture.destroy();
+  return error ? 1 : 4;
+}
+export {
+  capabilitiesOf,
+  isCoreDevice,
+  probeHdrSampleCount
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-gpu",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -20,7 +20,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@aethervtt/shard-core": "0.0.1"
+    "@aethervtt/shard-core": "0.1.0",
+    "@aethervtt/shard-gpu-webgl2": "0.1.0"
   },
   "repository": {
     "type": "git",
@@ -32,7 +33,7 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
   },
   "peerDependencies": {
     "webgpu": "0.6.1"