@woosh/meep-engine 3.45.0 → 3.47.0

package/src/shade/device/graph/TextureResourceDescriptor.js

@@ -1,174 +1,179 @@
-import { assert } from "../../../core/assert.js";
-import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
-import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
-import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
-import {
-    ResourceDescriptor
-} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
-import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
-import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
-import { GPUTextureUsage } from "../../descriptor/GPUTextureUsage.js";
-
-/**
- * **Vestigial.** Nothing branches on it — see {@link TextureResourceDescriptor.resolution_domain}.
- *
- * @enum {number}
- */
-export const TextureResolutionDomain = {
-    Absolute: 0,
-    PresentationRelative: 1
-}
-
-export class TextureResourceDescriptor extends ResourceDescriptor {
-    /**
-     * **Vestigial. Do not read this to decide how to interpret {@link resolution}.**
-     *
-     * No code branches on it; only {@link hash} folds it in. {@link from} stores whatever
-     * resolution it is given without touching this field, and every caller gives it pixels — so a
-     * descriptor's resolution is absolute pixels whatever this says, including on the default
-     * `PresentationRelative` that {@link from} leaves in place.
-     *
-     * @type {TextureResolutionDomain|number}
-     */
-    resolution_domain = TextureResolutionDomain.PresentationRelative;
-
-    // TODO use Uint32 instead
-    resolution = new Float64Array([1, 1, 1]);
-    sampleCount = 1;
-
-    mipLevelCount = 1;
-
-    /**
-     *
-     * @type {GPUTextureDimension|string}
-     */
-    dimension = "2d"
-
-    /**
-     * @type {string|GPUTextureFormat}
-     */
-    format = "rgba8unorm";
-
-    /**
-     * @type {number|GPUTextureUsageFlags}
-     */
-    usage = GPUTextureUsage.TEXTURE_BINDING;
-
-    /**
-     *
-     * @param {Object} options
-     * @param {number[]} options.resolution
-     * @param {GPUTextureDimension|string} [options.dimension]
-     * @param {GPUTextureFormat|string} options.format
-     * @param {GPUTextureUsageFlags|number} [options.usage]
-     * @param {boolean} [options.enableMips]
-     * @returns {TextureResourceDescriptor}
-     */
-    static from({
-                    resolution,
-                    dimension = "2d",
-                    format,
-                    usage = GPUTextureUsage.TEXTURE_BINDING,
-                    enableMips = false
-                }) {
-
-        assert.isString(format, 'format');
-        assert.defined(resolution, 'resolution');
-        assert.isArrayLike(resolution, 'resolution');
-        assert.isBoolean(enableMips, 'enableMips');
-
-        const r = new TextureResourceDescriptor();
-
-        array_copy(resolution, 0, r.resolution, 0, Math.min(r.resolution.length, resolution.length));
-        r.dimension = dimension;
-        r.format = format;
-        r.usage = usage;
-
-        if (enableMips === true) {
-
-            // `r.resolution` rather than the argument: it has already been padded to three, so a
-            // caller that gave two axes reads as depth 1 instead of `undefined`
-            r.mipLevelCount = texture_mip_level_count(
-                r.resolution[0], r.resolution[1], r.resolution[2], r.dimension
-            );
-
-        }
-
-        return r;
-
-    }
-
-    /**
-     *
-     * @param {GPUTexture} texture
-     * @returns {TextureResourceDescriptor}
-     */
-    static fromTexture(texture) {
-        const r = new TextureResourceDescriptor();
-
-        r.format = texture.format;
-        r.dimension = texture.dimension;
-
-        r.usage = texture.usage;
-        r.sampleCount = texture.sampleCount;
-        r.resolution_domain = TextureResolutionDomain.Absolute;
-
-        r.resolution[0] = texture.width;
-        r.resolution[1] = texture.height;
-        r.resolution[2] = texture.depthOrArrayLayers;
-
-
-        r.mipLevelCount = texture.mipLevelCount;
-
-        return r;
-    }
-
-    get type() {
-        return "texture";
-    }
-
-    hash() {
-        return combine_hash(
-            this.resolution_domain,
-            this.mipLevelCount,
-            computeHashFloatArray(this.resolution),
-            this.sampleCount,
-            this.usage,
-            computeStringHash(this.format)
-        );
-    }
-
-    /**
-     *
-     * @param {TextureResourceDescriptor} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        if (this === other) {
-            return true;
-        }
-
-        // A texture and a buffer descriptor share one `ImmutableObjectPool` in
-        // `RenderResourceManager`, so a hash collision puts a buffer in front of this method. The
-        // type check has to come first: without it the very next line reads `other.resolution.length`
-        // on undefined and the probe throws instead of missing the cache.
-        if (!super.equals(other)) {
-            return false;
-        }
-
-        return isArrayEqualStrict(this.resolution, other.resolution)
-            && this.mipLevelCount === other.mipLevelCount
-            && this.resolution_domain === other.resolution_domain
-            && this.sampleCount === other.sampleCount
-            && this.dimension === other.dimension
-            && this.format === other.format
-            && this.usage === other.usage
-            ;
-    }
-
-    toString() {
-        return `Texture{ resolution = [${this.resolution.join(",")}], mipLevelCount = ${this.mipLevelCount}, dimension = ${this.dimension}, format = ${this.format}, usage = ${decode_bitmask_enum(this.usage, GPUTextureUsage).join(' | ')}, sampleCount = ${this.sampleCount} }`;
-    }
+import { assert } from "../../../core/assert.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import {
+    ResourceDescriptor
+} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
+import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
+import { GPUTextureUsage } from "../../descriptor/GPUTextureUsage.js";
+
+/**
+ * **Vestigial.** Nothing branches on it — see {@link TextureResourceDescriptor.resolution_domain}.
+ *
+ * @enum {number}
+ */
+export const TextureResolutionDomain = {
+    Absolute: 0,
+    PresentationRelative: 1
+}
+
+export class TextureResourceDescriptor extends ResourceDescriptor {
+    /**
+     * **Vestigial. Do not read this to decide how to interpret {@link resolution}.**
+     *
+     * No code branches on it; only {@link hash} folds it in. {@link from} stores whatever
+     * resolution it is given without touching this field, and every caller gives it pixels — so a
+     * descriptor's resolution is absolute pixels whatever this says, including on the default
+     * `PresentationRelative` that {@link from} leaves in place.
+     *
+     * @type {TextureResolutionDomain|number}
+     */
+    resolution_domain = TextureResolutionDomain.PresentationRelative;
+
+    // TODO use Uint32 instead
+    resolution = new Float64Array([1, 1, 1]);
+    sampleCount = 1;
+
+    mipLevelCount = 1;
+
+    /**
+     *
+     * @type {GPUTextureDimension|string}
+     */
+    dimension = "2d"
+
+    /**
+     * @type {string|GPUTextureFormat}
+     */
+    format = "rgba8unorm";
+
+    /**
+     * @type {number|GPUTextureUsageFlags}
+     */
+    usage = GPUTextureUsage.TEXTURE_BINDING;
+
+    /**
+     *
+     * @param {Object} options
+     * @param {number[]} options.resolution
+     * @param {GPUTextureDimension|string} [options.dimension]
+     * @param {GPUTextureFormat|string} options.format
+     * @param {GPUTextureUsageFlags|number} [options.usage]
+     * @param {boolean} [options.enableMips]
+     * @returns {TextureResourceDescriptor}
+     */
+    static from({
+                    resolution,
+                    dimension = "2d",
+                    format,
+                    usage = GPUTextureUsage.TEXTURE_BINDING,
+                    enableMips = false
+                }) {
+
+        assert.isString(format, 'format');
+        assert.defined(resolution, 'resolution');
+        assert.isArrayLike(resolution, 'resolution');
+        assert.isBoolean(enableMips, 'enableMips');
+
+        const r = new TextureResourceDescriptor();
+
+        array_copy(resolution, 0, r.resolution, 0, Math.min(r.resolution.length, resolution.length));
+        r.dimension = dimension;
+        r.format = format;
+        r.usage = usage;
+
+        if (enableMips === true) {
+
+            // `r.resolution` rather than the argument: it has already been padded to three, so a
+            // caller that gave two axes reads as depth 1 instead of `undefined`
+            r.mipLevelCount = texture_mip_level_count(
+                r.resolution[0], r.resolution[1], r.resolution[2], r.dimension
+            );
+
+        }
+
+        return r;
+
+    }
+
+    /**
+     *
+     * @param {GPUTexture} texture
+     * @returns {TextureResourceDescriptor}
+     */
+    static fromTexture(texture) {
+        const r = new TextureResourceDescriptor();
+
+        r.format = texture.format;
+        r.dimension = texture.dimension;
+
+        r.usage = texture.usage;
+        r.sampleCount = texture.sampleCount;
+        r.resolution_domain = TextureResolutionDomain.Absolute;
+
+        r.resolution[0] = texture.width;
+        r.resolution[1] = texture.height;
+        r.resolution[2] = texture.depthOrArrayLayers;
+
+
+        r.mipLevelCount = texture.mipLevelCount;
+
+        return r;
+    }
+
+    get type() {
+        return "texture";
+    }
+
+    hash() {
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    this.resolution_domain,
+                    this.mipLevelCount,
+                    computeHashFloatArray(this.resolution)
+                ),
+                this.sampleCount,
+                this.usage
+            ),
+            computeStringHash(this.format)
+        );
+    }
+
+    /**
+     *
+     * @param {TextureResourceDescriptor} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+
+        // A texture and a buffer descriptor share one `ImmutableObjectPool` in
+        // `RenderResourceManager`, so a hash collision puts a buffer in front of this method. The
+        // type check has to come first: without it the very next line reads `other.resolution.length`
+        // on undefined and the probe throws instead of missing the cache.
+        if (!super.equals(other)) {
+            return false;
+        }
+
+        return isArrayEqualStrict(this.resolution, other.resolution)
+            && this.mipLevelCount === other.mipLevelCount
+            && this.resolution_domain === other.resolution_domain
+            && this.sampleCount === other.sampleCount
+            && this.dimension === other.dimension
+            && this.format === other.format
+            && this.usage === other.usage
+            ;
+    }
+
+    toString() {
+        return `Texture{ resolution = [${this.resolution.join(",")}], mipLevelCount = ${this.mipLevelCount}, dimension = ${this.dimension}, format = ${this.format}, usage = ${decode_bitmask_enum(this.usage, GPUTextureUsage).join(' | ')}, sampleCount = ${this.sampleCount} }`;
+    }
 }

package/src/shade/device/shade_device_floor_unmet.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Every way `adapter` falls short of {@link SHADE_DEVICE_FLOOR}, one phrase per gap, naming the
+ * feature or the limit and, for a limit, what the adapter offers against what is required. Empty
+ * when the adapter meets the floor.
+ *
+ * All of them rather than the first: somebody told about one gap at a time has to come back once per
+ * gap to learn whether their hardware can ever run this.
+ *
+ * @param {GPUAdapter} adapter
+ * @returns {string[]}
+ */
+export function shade_device_floor_unmet(adapter: GPUAdapter): string[];
+//# sourceMappingURL=shade_device_floor_unmet.d.ts.map

package/src/shade/device/shade_device_floor_unmet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shade_device_floor_unmet.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/shade_device_floor_unmet.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,+DAFa,MAAM,EAAE,CAoBpB"}

package/src/shade/device/shade_device_floor_unmet.js

@@ -0,0 +1,32 @@
+import { SHADE_DEVICE_FLOOR } from "./SHADE_DEVICE_FLOOR.js";
+
+/**
+ * Every way `adapter` falls short of {@link SHADE_DEVICE_FLOOR}, one phrase per gap, naming the
+ * feature or the limit and, for a limit, what the adapter offers against what is required. Empty
+ * when the adapter meets the floor.
+ *
+ * All of them rather than the first: somebody told about one gap at a time has to come back once per
+ * gap to learn whether their hardware can ever run this.
+ *
+ * @param {GPUAdapter} adapter
+ * @returns {string[]}
+ */
+export function shade_device_floor_unmet(adapter) {
+    const unmet = [];
+
+    for (const feature of SHADE_DEVICE_FLOOR.features) {
+        if (!adapter.features.has(feature)) {
+            unmet.push(`feature '${feature}' is not supported`);
+        }
+    }
+
+    for (const [name, required] of Object.entries(SHADE_DEVICE_FLOOR.limits)) {
+        const offered = adapter.limits[name];
+
+        if (offered < required) {
+            unmet.push(`limit ${name} is ${offered}, at least ${required} is required`);
+        }
+    }
+
+    return unmet;
+}

package/src/shade/device/timing/profile/sgpt_read_header.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_DEFECT } from "./SGPT_DEFECT.js";
 import { SGPTDefect } from "./SGPTDefect.js";
 import { SGPT_FORMAT_VERSION } from "./SGPT_FORMAT_VERSION.js";

package/src/shade/device/timing/profile/sgpt_read_records.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_DEFECT } from "./SGPT_DEFECT.js";
 import { SGPTDefect } from "./SGPTDefect.js";
 import { SGPT_HEADER_SIZE } from "./SGPT_HEADER_SIZE.js";

package/src/shade/device/timing/profile/sgpt_write_header.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_FORMAT_VERSION } from "./SGPT_FORMAT_VERSION.js";
 import { SGPT_HEADER_CHECKSUM_COVERAGE } from "./SGPT_HEADER_CHECKSUM_COVERAGE.js";
 import { SGPT_HEADER_OFFSET } from "./SGPT_HEADER_OFFSET.js";

package/src/shade/device/timing/profile/sgpt_write_record.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { crc32 } from "../../../../core/math/hash/crc32.js";
 import { SGPT_RECORD_HEADER_SIZE } from "./SGPT_RECORD_HEADER_SIZE.js";
 import { SGPT_RECORD_SYNC } from "./SGPT_RECORD_SYNC.js";
 

package/src/shade/renderer/Renderer.d.ts

@@ -421,6 +421,8 @@ export class Renderer {
      */
     get nss(): NSS;
     /**
+     * Rejects with a {@link ShadeDeviceFailure} when there is no usable device — no WebGPU, no
+     * adapter, an adapter below {@link SHADE_DEVICE_FLOOR}, or a refused device request.
      *
      * @param {Object} [options]
      * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AAmHA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAYD,oCAIC;IAED,mCAEC;IAED;;;;;;OAMG;IACH,6BAFU,OAAO,CAEmB;IASpC,0CAIC;IAED,yCAEC;IAED;;;;;OAKG;IACH,yBAFU,MAAM,CAEY;IAS5B,+CAKC;IAED,8CAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,oCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CAI3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IA8OD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;;;;OAQG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBAsMhB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CAuChB;IAgCD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;;;;;;OAeG;IACH,eAVW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAyBnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CAsiCJ;+BA76FY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BA1BhB,yBAAyB;0CACZ,gCAAgC;sCACpC,4BAA4B;+BACnC,6CAA6C;2BA1BjD,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BA2C7C,uBAAuB;gCAhDnB,sBAAsB;oBAtClC,4BAA4B;kCAmFd,gCAAgC;2BA9DvC,2BAA2B;iCA4DrB,0CAA0C;4CA9C/B,+DAA+D;yBAgClF,yBAAyB;kCAChB,kCAAkC;kCAQlC,wBAAwB;oBA7BtC,0BAA0B;uCAPP,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -11,6 +11,8 @@ import {
 import { FrameGraph } from "../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { TextureDescriptor } from "../descriptor/texture/TextureDescriptor.js";
 import { WebGPUExtensionType } from "../descriptor/WebGPUExtensionType.js";
+import { SHADE_DEVICE_FLOOR } from "../device/SHADE_DEVICE_FLOOR.js";
+import { shade_device_floor_unmet } from "../device/shade_device_floor_unmet.js";
 import { ShadeDeviceFailure } from "../device/ShadeDeviceFailure.js";
 import { ShadeGPUCommandContext } from "../device/ShadeGPUCommandContext.js";
 import { CameraManager } from "./camera/CameraManager.js";
@@ -1375,6 +1377,8 @@ export class Renderer {
     }
 
     /**
+     * Rejects with a {@link ShadeDeviceFailure} when there is no usable device — no WebGPU, no
+     * adapter, an adapter below {@link SHADE_DEVICE_FLOOR}, or a refused device request.
      *
      * @param {Object} [options]
      * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.
@@ -1387,8 +1391,8 @@ export class Renderer {
                          pixelRatio = window.devicePixelRatio,
                      } = {}) {
 
-        if (!('gpu' in navigator)) {
-            throw new Error('navigator.gpu not available — WebGPU disabled or unsupported');
+        if (navigator.gpu === undefined) {
+            throw ShadeDeviceFailure.webgpu_unavailable();
         }
 
         this.#update_presentation_format();
@@ -1414,13 +1418,7 @@ export class Renderer {
         if (device === undefined) {
             // no device present, let's create one
 
-            const gpu = navigator.gpu;
-
-            if (gpu === undefined) {
-                throw ShadeDeviceFailure.webgpu_unavailable();
-            }
-
-            const adapter = await gpu.requestAdapter({
+            const adapter = await navigator.gpu.requestAdapter({
                 powerPreference: "high-performance",
             });
 
@@ -1441,27 +1439,22 @@ export class Renderer {
             //
             // console.warn('adapter limits:', adapter.limits);
 
-            const maxStorageBuffersPerShaderStage = adapter.limits.maxStorageBuffersPerShaderStage;
+            // The whole floor is checked before a device is asked for, so a refusal names every gap,
+            // with the numbers this adapter offers, rather than whichever one requestDevice trips on.
+            const unmet = shade_device_floor_unmet(adapter);
 
-            if (maxStorageBuffersPerShaderStage < 10) {
-                throw ShadeDeviceFailure.below_floor(
-                    `requires at least 10 storage buffers per shader stage, adapter offers ${maxStorageBuffersPerShaderStage}`
-                );
+            if (unmet.length > 0) {
+                throw ShadeDeviceFailure.below_floor(unmet);
             }
 
-            const requiredFeatures = [
-                // required for indirect draw that's used extensively in Shade
-                WebGPUExtensionType.IndirectFirstInstance,
-                // required for OIT (might be unavailable)
-                WebGPUExtensionType.Float32Blendable,
-            ];
+            const requiredFeatures = SHADE_DEVICE_FLOOR.features.slice();
 
             // add features if they are available
             const optional_desired = [
                 // Profiling only, and some browsers withhold it on hardware that is otherwise
                 // fine — so it is taken when offered and the timers go quiet when it is not
                 // (E7, sponsor 2026-08-16). Requiring it would refuse to start on those browsers
-                // for the sake of a feature the game does not need to run.
+                // for the sake of a feature the renderer does not need to run.
                 WebGPUExtensionType.TimestampQuery,
                 WebGPUExtensionType.Subgroups,
                 WebGPUExtensionType.TextureFormatsTier1,
@@ -1475,35 +1468,28 @@ export class Renderer {
                 WebGPUExtensionType.TextureCompressionASTC,
             ];
 
-            // valid required features
-            for (const feature of requiredFeatures) {
-                if (!adapter.features.has(feature)) {
-                    throw ShadeDeviceFailure.below_floor(`adapter does not support required feature '${feature}'`);
-                }
-            }
-
             for (const feature of optional_desired) {
                 if (adapter.features.has(feature)) {
                     requiredFeatures.push(feature);
                 }
             }
 
+            try {
+                device = await adapter.requestDevice({
+                    requiredLimits: {
+                        ...SHADE_DEVICE_FLOOR.limits,
 
-            device = await adapter.requestDevice({
-                requiredLimits: {
-                    // required for large G-buffers
-                    maxColorAttachmentBytesPerSample: 32,
-
-                    /*
-                     grab the largest buffer limit we can get, default limits are super-low
-                     */
-                    maxBufferSize: adapter.limits.maxBufferSize,
-                    maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
-
-                    maxStorageBuffersPerShaderStage: 10,
-                },
-                requiredFeatures
-            });
+                        /*
+                         grab the largest buffer limit we can get, default limits are super-low
+                         */
+                        maxBufferSize: adapter.limits.maxBufferSize,
+                        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+                    },
+                    requiredFeatures
+                });
+            } catch (error) {
+                throw ShadeDeviceFailure.device_request_failed(error.message);
+            }
 
             // NOTE: according to spec (as of 2025/09/19) - adapter can only be used to create one device, after which it becomes "consumed"
             //       see https://www.w3.org/TR/webgpu/#adapters
@@ -1515,18 +1501,6 @@ export class Renderer {
             this.#handle_device_lost(info);
         })
 
-        if (context === undefined) {
-            const canvas = document.createElement('canvas');
-            canvas.width = window.innerWidth;
-            canvas.height = window.innerHeight;
-
-            context = canvas.getContext('webgpu');
-
-            if (context === null) {
-                throw new Error('Failed to bind GPUCanvasContext');
-            }
-        }
-
         assert.ok(device.features.has("indirect-first-instance"), '"indirect-first-instance" feature needs to be enabled for non-zero firstInstance values to be used.')
         assert.isInstanceOf(context, GPUCanvasContext, 'context', 'GPUCanvasContext');
 

package/src/shade/renderer/binding/BufferBinding.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import { BindingResource } from "./BindingResource.js";
 
 /**
@@ -35,7 +35,7 @@ export class BufferBinding extends BindingResource {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix3(
             this.offset,
             this.actual_size,
             this.buffer.id

package/src/shade/renderer/buffer/GPUBufferAllocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUBufferAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/GPUBufferAllocator.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IAOI;;OAEG;IACH,+BAKC;IAED,8BAEC;IAED,gCAEC;IAED,yBAEC;IAED,2BAWC;IAED,mCAEC;;CAoDJ;sCAlHqC,kCAAkC"}
+{"version":3,"file":"GPUBufferAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/GPUBufferAllocator.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IAOI;;OAEG;IACH,+BAKC;IAED,8BAEC;IAED,gCAEC;IAWD,yBAEC;IAED,2BAWC;IAED,mCAEC;;CAoDJ;sCA3HqC,kCAAkC"}