@woosh/meep-engine 3.46.0 → 3.47.0

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

@@ -2,12 +2,18 @@
  * Why there is no usable device, in a form a host can act on.
  *
  * It is an `Error` because that is what the failure paths already throw and callers already
- * `catch`, and it carries a {@link ShadeDeviceFailureReason} because a host showing this to a player
+ * `catch`, and it carries a {@link ShadeDeviceFailureReason} because a host showing this to a person
  * needs to distinguish "your browser cannot do this at all" from "your GPU is below what this needs"
  * from "the GPU went away" — three different things to tell somebody, and none of them a stack
  * trace.
  *
- * `detail` holds the specific thing that was missing, for the log rather than the player.
+ * The `message` is written to be shown as it is. Where the specifics are something a person can act
+ * on — which features and limits the hardware lacks, what the browser refused — it names them, so
+ * that what reaches a support thread is the answer rather than a request for logs. `detail` holds
+ * the specifics alone, for a host that phrases its own message.
+ *
+ * Nothing here assumes what the application is: the same engine runs games, CAD tools and product
+ * visualizers, and they all show these messages.
  */
 export class ShadeDeviceFailure extends Error {
     /**
@@ -19,12 +25,13 @@ export class ShadeDeviceFailure extends Error {
      */
     static adapter_unavailable(): ShadeDeviceFailure;
     /**
-     * @param {string} detail what was missing
+     * @param {string[]} unmet every requirement the adapter falls short of, as
+     * {@link shade_device_floor_unmet} phrases them
      * @returns {ShadeDeviceFailure}
      */
-    static below_floor(detail: string): ShadeDeviceFailure;
+    static below_floor(unmet: string[]): ShadeDeviceFailure;
     /**
-     * @param {string} detail
+     * @param {string} detail what the browser said when it refused
      * @returns {ShadeDeviceFailure}
      */
     static device_request_failed(detail: string): ShadeDeviceFailure;

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

@@ -1 +1 @@
-{"version":3,"file":"ShadeDeviceFailure.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/ShadeDeviceFailure.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IA2BI;;OAEG;IACH,6BAFa,kBAAkB,CAQ9B;IAED;;OAEG;IACH,8BAFa,kBAAkB,CAQ9B;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,kBAAkB,CAQ9B;IAED;;;OAGG;IACH,qCAHW,MAAM,GACJ,kBAAkB,CAQ9B;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,kBAAkB,CAQ9B;IArED;;;;OAIG;IACH,oBAJW,wBAAwB,WACxB,MAAM,WACN,MAAM,EAQhB;IAxBD;;OAEG;IACH,QAFU,wBAAwB,CAEkB;IAEpD;;;;;OAKG;IACH,QAFU,MAAM,CAEJ;IA0EhB;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CANhD;yCAjGwC,+BAA+B"}
+{"version":3,"file":"ShadeDeviceFailure.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/ShadeDeviceFailure.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IA2BI;;OAEG;IACH,6BAFa,kBAAkB,CAQ9B;IAED;;OAEG;IACH,8BAFa,kBAAkB,CAQ9B;IAED;;;;OAIG;IACH,0BAJW,MAAM,EAAE,GAEN,kBAAkB,CAU9B;IAED;;;OAGG;IACH,qCAHW,MAAM,GACJ,kBAAkB,CAQ9B;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,kBAAkB,CAQ9B;IAxED;;;;OAIG;IACH,oBAJW,wBAAwB,WACxB,MAAM,WACN,MAAM,EAQhB;IAxBD;;OAEG;IACH,QAFU,wBAAwB,CAEkB;IAEpD;;;;;OAKG;IACH,QAFU,MAAM,CAEJ;IA6EhB;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CANhD;yCA1GwC,+BAA+B"}

package/src/shade/device/ShadeDeviceFailure.js

@@ -4,12 +4,18 @@ import { ShadeDeviceFailureReason } from "./ShadeDeviceFailureReason.js";
  * Why there is no usable device, in a form a host can act on.
  *
  * It is an `Error` because that is what the failure paths already throw and callers already
- * `catch`, and it carries a {@link ShadeDeviceFailureReason} because a host showing this to a player
+ * `catch`, and it carries a {@link ShadeDeviceFailureReason} because a host showing this to a person
  * needs to distinguish "your browser cannot do this at all" from "your GPU is below what this needs"
  * from "the GPU went away" — three different things to tell somebody, and none of them a stack
  * trace.
  *
- * `detail` holds the specific thing that was missing, for the log rather than the player.
+ * The `message` is written to be shown as it is. Where the specifics are something a person can act
+ * on — which features and limits the hardware lacks, what the browser refused — it names them, so
+ * that what reaches a support thread is the answer rather than a request for logs. `detail` holds
+ * the specifics alone, for a host that phrases its own message.
+ *
+ * Nothing here assumes what the application is: the same engine runs games, CAD tools and product
+ * visualizers, and they all show these messages.
  */
 export class ShadeDeviceFailure extends Error {
     /**
@@ -44,7 +50,7 @@ export class ShadeDeviceFailure extends Error {
     static webgpu_unavailable() {
         return new ShadeDeviceFailure(
             ShadeDeviceFailureReason.WebGPUUnavailable,
-            "This browser does not support WebGPU, which this game requires.",
+            "This browser does not support WebGPU, which this application requires.",
             "navigator.gpu is undefined"
         );
     }
@@ -61,25 +67,28 @@ export class ShadeDeviceFailure extends Error {
     }
 
     /**
-     * @param {string} detail what was missing
+     * @param {string[]} unmet every requirement the adapter falls short of, as
+     * {@link shade_device_floor_unmet} phrases them
      * @returns {ShadeDeviceFailure}
      */
-    static below_floor(detail) {
+    static below_floor(unmet) {
+        const detail = unmet.join('; ');
+
         return new ShadeDeviceFailure(
             ShadeDeviceFailureReason.BelowFloor,
-            "This graphics hardware is below the minimum this game requires.",
+            `This graphics hardware does not meet this application's minimum requirements: ${detail}.`,
             detail
         );
     }
 
     /**
-     * @param {string} detail
+     * @param {string} detail what the browser said when it refused
      * @returns {ShadeDeviceFailure}
      */
     static device_request_failed(detail) {
         return new ShadeDeviceFailure(
             ShadeDeviceFailureReason.DeviceRequestFailed,
-            "The graphics device could not be created.",
+            `The graphics device could not be created: ${detail}`,
             detail
         );
     }

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

@@ -4,7 +4,7 @@
  * The device floor is deliberate and fixed (D6/I-8): there are no degradation tiers, no WebGL
  * fallback and no feature-detection branches. Hardware below the floor is not accommodated — it is
  * told, clearly, that it cannot run this. That makes the *message* the entire below-floor
- * behaviour the engine owes, and a reason code is what lets a host phrase it for a player rather
+ * behaviour the engine owes, and a reason code is what lets a host phrase it for a person rather
  * than showing them a stack trace.
  */
 export type ShadeDeviceFailureReason = number;

package/src/shade/device/ShadeDeviceFailureReason.js

@@ -4,7 +4,7 @@
  * The device floor is deliberate and fixed (D6/I-8): there are no degradation tiers, no WebGL
  * fallback and no feature-detection branches. Hardware below the floor is not accommodated — it is
  * told, clearly, that it cannot run this. That makes the *message* the entire below-floor
- * behaviour the engine owes, and a reason code is what lets a host phrase it for a player rather
+ * behaviour the engine owes, and a reason code is what lets a host phrase it for a person rather
  * than showing them a stack trace.
  *
  * @enum {number}
@@ -23,7 +23,7 @@ export const ShadeDeviceFailureReason = {
 
     /**
      * An adapter exists and is below the floor — a required feature or limit is missing. The
-     * failure names which one.
+     * failure names every one.
      */
     BelowFloor: 2,
 

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/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":"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"}

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/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"}

package/src/shade/renderer/buffer/GPUBufferAllocator.js

@@ -42,6 +42,15 @@ export class GPUBufferAllocator extends TransientResourcePool {
         return buffer_compare(a, b);
     }
 
+    /**
+     * The usage the buffer was made with, kept on its record beside the size the pool keeps: the order
+     * and the match read both, and a `GPUBuffer`'s are native reads.
+     * @param {import("../pool/TransientResourcePool.js").PoolRecord} record
+     */
+    describeRecord(record) {
+        record.usage = record.resource.usage;
+    }
+
     sizeOf(buffer) {
         return buffer.size;
     }

package/src/shade/renderer/buffer/buffer_pool_ops.d.ts

@@ -1,5 +1,5 @@
 /**
- * Total order over `{usage, size}`-bearing specs (a request descriptor or a live GPUBuffer).
+ * Total order over `{usage, size}`-bearing specs: a request descriptor, or a pool record.
  *
  * Sorted by size first (so the binary search lands on the smallest fitting buffer), then by usage
  * *bit-count* (so the narrowest-usage buffer is preferred — wide-usage buffers map to slower driver
@@ -16,29 +16,30 @@ export function compare_memory_spec(a: {
     usage: number;
     size: number;
 }): number;
+/**
+ * A pool record as {@link GPUBufferAllocator} keeps one: the buffer, and its `size` and `usage` as they
+ * were when it entered the pool. Ordering and matching read those, never the buffer, whose `size` and
+ * `usage` are native reads and are visited by the binary search and the scan many times a frame.
+ *
+ * @typedef {import("../pool/TransientResourcePool.js").PoolRecord & {usage: number}} BufferPoolRecord
+ */
 /**
  * Record ordering for the pool's sorted insert.
  *
- * @param {{resource:GPUBuffer}} a
- * @param {{resource:GPUBuffer}} b
+ * @param {BufferPoolRecord} a
+ * @param {BufferPoolRecord} b
  * @returns {number}
  */
-export function buffer_compare(a: {
-    resource: GPUBuffer;
-}, b: {
-    resource: GPUBuffer;
-}): number;
+export function buffer_compare(a: BufferPoolRecord, b: BufferPoolRecord): number;
 /**
  * Approximate first-fit: the smallest pooled buffer with `size >= request` and a usage *superset* of
  * the request, bounded against handing out a much-larger buffer.
  *
- * @param {{resource:GPUBuffer}[]} records sorted under {@link buffer_compare}
+ * @param {BufferPoolRecord[]} records sorted under {@link buffer_compare}
  * @param {{size:number, usage:number}} descriptor
  * @returns {number} index of a satisfying record, or -1
  */
-export function buffer_find(records: {
-    resource: GPUBuffer;
-}[], descriptor: {
+export function buffer_find(records: BufferPoolRecord[], descriptor: {
     size: number;
     usage: number;
 }): number;
@@ -63,4 +64,12 @@ export const ALLOW_LARGER_LIMIT_SCALE: number;
  * @type {number}
  */
 export const ALLOW_LARGER_LIMIT_FIXED: number;
+/**
+ * A pool record as {@link GPUBufferAllocator } keeps one: the buffer, and its `size` and `usage` as they
+ * were when it entered the pool. Ordering and matching read those, never the buffer, whose `size` and
+ * `usage` are native reads and are visited by the binary search and the scan many times a frame.
+ */
+export type BufferPoolRecord = import("../pool/TransientResourcePool.js").PoolRecord & {
+    usage: number;
+};
 //# sourceMappingURL=buffer_pool_ops.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_pool_ops.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/buffer_pool_ops.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;GAUG;AACH,uCAJW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,KAC3B;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAqBlB;AAED;;;;;;GAMG;AACH,kCAJW;IAAC,QAAQ,YAAU;CAAC,KACpB;IAAC,QAAQ,YAAU;CAAC,GAClB,MAAM,CAIlB;AAWD;;;;;;;GAOG;AACH,qCAJW;IAAC,QAAQ,YAAU;CAAC,EAAE,cACtB;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAmClB;AAED;;;GAGG;AACH,mDAFa,MAAM,CAIlB;AAvHD;;;GAGG;AAEH;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAC1C;;;;GAIG;AACH,uCAFU,MAAM,CAE6B"}
+{"version":3,"file":"buffer_pool_ops.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/buffer_pool_ops.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;GAUG;AACH,uCAJW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,KAC3B;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAqBlB;AAED;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,kCAJW,gBAAgB,KAChB,gBAAgB,GACd,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,qCAJW,gBAAgB,EAAE,cAClB;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAA;CAAC,GACzB,MAAM,CAmClB;AAED;;;GAGG;AACH,mDAFa,MAAM,CAIlB;AAtHD;;;GAGG;AAEH;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAC1C;;;;GAIG;AACH,uCAFU,MAAM,CAE6B;;;;;;+BAuChC,OAAO,kCAAkC,EAAE,UAAU,GAAG;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC"}

package/src/shade/renderer/buffer/buffer_pool_ops.js

@@ -20,7 +20,7 @@ export const ALLOW_LARGER_LIMIT_SCALE = 2;
 export const ALLOW_LARGER_LIMIT_FIXED = 1024;
 
 /**
- * Total order over `{usage, size}`-bearing specs (a request descriptor or a live GPUBuffer).
+ * Total order over `{usage, size}`-bearing specs: a request descriptor, or a pool record.
  *
  * Sorted by size first (so the binary search lands on the smallest fitting buffer), then by usage
  * *bit-count* (so the narrowest-usage buffer is preferred — wide-usage buffers map to slower driver
@@ -52,37 +52,36 @@ export function compare_memory_spec(a, b) {
 }
 
 /**
- * Record ordering for the pool's sorted insert.
+ * A pool record as {@link GPUBufferAllocator} keeps one: the buffer, and its `size` and `usage` as they
+ * were when it entered the pool. Ordering and matching read those, never the buffer, whose `size` and
+ * `usage` are native reads and are visited by the binary search and the scan many times a frame.
  *
- * @param {{resource:GPUBuffer}} a
- * @param {{resource:GPUBuffer}} b
- * @returns {number}
+ * @typedef {import("../pool/TransientResourcePool.js").PoolRecord & {usage: number}} BufferPoolRecord
  */
-export function buffer_compare(a, b) {
-    return compare_memory_spec(a.resource, b.resource);
-}
 
 /**
- * @param {{resource:GPUBuffer}} record
- * @param {{size:number}} descriptor
+ * Record ordering for the pool's sorted insert.
+ *
+ * @param {BufferPoolRecord} a
+ * @param {BufferPoolRecord} b
  * @returns {number}
  */
-function compare_descriptor_to_record(descriptor, record) {
-    return compare_memory_spec(descriptor, record.resource);
+export function buffer_compare(a, b) {
+    return compare_memory_spec(a, b);
 }
 
 /**
  * Approximate first-fit: the smallest pooled buffer with `size >= request` and a usage *superset* of
  * the request, bounded against handing out a much-larger buffer.
  *
- * @param {{resource:GPUBuffer}[]} records sorted under {@link buffer_compare}
+ * @param {BufferPoolRecord[]} records sorted under {@link buffer_compare}
  * @param {{size:number, usage:number}} descriptor
  * @returns {number} index of a satisfying record, or -1
  */
 export function buffer_find(records, descriptor) {
     const count = records.length;
 
-    let index = binarySearchHighIndex(records, descriptor, compare_descriptor_to_record);
+    let index = binarySearchHighIndex(records, descriptor, compare_memory_spec);
 
     if (index >= count) {
         return -1;
@@ -93,19 +92,19 @@ export function buffer_find(records, descriptor) {
     }
 
     for (; index < count; index++) {
-        const buffer = records[index].resource;
+        const record = records[index];
 
         if (
-            buffer.size > descriptor.size * ALLOW_LARGER_LIMIT_SCALE
-            && (buffer.size - descriptor.size) > ALLOW_LARGER_LIMIT_FIXED
+            record.size > descriptor.size * ALLOW_LARGER_LIMIT_SCALE
+            && (record.size - descriptor.size) > ALLOW_LARGER_LIMIT_FIXED
         ) {
             // records are sorted by size: everything from here on is too large
             break;
         }
 
         if (
-            (buffer.usage & descriptor.usage) === descriptor.usage
-            && buffer.size >= descriptor.size
+            (record.usage & descriptor.usage) === descriptor.usage
+            && record.size >= descriptor.size
         ) {
             return index;
         }

package/src/shade/renderer/gpu_primitive/test/gpu_test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu_test.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/test/gpu_test.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,sCAJW,MAAM,cAEL,QAAQ,IAAI,CAAC,CA+DxB"}
+{"version":3,"file":"gpu_test.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/test/gpu_test.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,sCAJW,MAAM,cAEL,QAAQ,IAAI,CAAC,CAyDxB"}

package/src/shade/renderer/gpu_primitive/test/gpu_test.js

@@ -1,4 +1,7 @@
 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 { GraphicsContext } from "../../GraphicsContext.js";
 
 /**
@@ -36,32 +39,26 @@ export async function gpu_test(description, body) {
     //
     // console.warn('adapter limits:', adapter.limits);
 
-    const maxStorageBuffersPerShaderStage = adapter.limits.maxStorageBuffersPerShaderStage;
+    const unmet = shade_device_floor_unmet(adapter);
 
-    if (maxStorageBuffersPerShaderStage < 10) {
-        throw new Error(`Engine requires at least 10 storage buffers per shader stage, actual is ${maxStorageBuffersPerShaderStage}`);
+    if (unmet.length > 0) {
+        throw ShadeDeviceFailure.below_floor(unmet);
     }
 
     const device = await adapter.requestDevice({
         requiredLimits: {
-            // required for large G-buffers
-            maxColorAttachmentBytesPerSample: 32,
+            ...SHADE_DEVICE_FLOOR.limits,
 
             /*
              grab the largest buffer limit we can get, default limits are super-low
              */
             maxBufferSize: adapter.limits.maxBufferSize,
             maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
-
-            maxStorageBuffersPerShaderStage: 10,
         },
         requiredFeatures: [
+            ...SHADE_DEVICE_FLOOR.features,
             // required for timers
             WebGPUExtensionType.TimestampQuery,
-            // required for indirect draw that's used extensively in Shade
-            WebGPUExtensionType.IndirectFirstInstance,
-            // required for OIT
-            WebGPUExtensionType.Float32Blendable,
         ]
     });
 

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#265@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#267@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]