@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/device/mock/SoftwareGPUDevice.js

@@ -12,8 +12,10 @@ import { SoftwareGPUSampler } from "./SoftwareGPUSampler.js";
 import { SoftwareGPUShaderModule } from "./SoftwareGPUShaderModule.js";
 import { SoftwareGPUTexture } from "./SoftwareGPUTexture.js";
 import { SoftwareGPUUncapturedErrorEvent } from "./SoftwareGPUUncapturedErrorEvent.js";
+import { texture_view_resource_refusal } from "./texture_view_resource.js";
 import { gpu_texture_format_feature } from "../../descriptor/texture/format/gpu_texture_format_feature.js";
 import { gpu_texture_format_info } from "../../descriptor/texture/format/gpu_texture_format_info.js";
+import { gpu_texture_formats_view_compatible } from "../../descriptor/texture/format/gpu_texture_formats_view_compatible.js";
 
 /**
  * The limits a device reports when nothing was asked for — the spec's default values, which is what
@@ -705,6 +707,17 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
             } catch (error) {
                 return `viewFormats: ${error.message}`;
             }
+
+            /*
+             A real device refuses the whole texture for a view format that differs from its own by
+             more than -srgb. createView trusts this list, so while this checked only that each entry
+             was a format, an rgba8unorm texture declared with r32float could be viewed as r32float
+             here and on no GPU.
+            */
+            if (!gpu_texture_formats_view_compatible(descriptor.format, view_format, this.#features)) {
+                return `viewFormats: '${view_format}' is not texture view format compatible with the texture's`
+                    + ` '${descriptor.format}'; a view cannot change format beyond adding or dropping -srgb`;
+            }
         }
 
         const limits = this.limits;
@@ -800,13 +813,57 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
     }
 
     /**
+     * A bind group naming a resource the device refused is reported through the error scopes and
+     * answered with an invalid bind group, the same way {@link createBuffer} answers a descriptor it
+     * will not honour — and a pass that sets it fails with it, at the encoder's `finish()`.
+     *
      * @param {GPUBindGroupDescriptor} descriptor
-     * @returns {GPUBindGroup}
+     * @returns {GPUBindGroup} invalid when the descriptor was refused
      */
     createBindGroup(descriptor) {
+        const refusal = this.#create_bind_group_refusal(descriptor);
+
+        if (refusal !== null) {
+            this.generate_error(new SoftwareGPUValidationError(`createBindGroup: ${refusal}`));
+
+            return SoftwareGPUBindGroup.invalid(descriptor);
+        }
+
         return new SoftwareGPUBindGroup(descriptor);
     }
 
+    /**
+     * Why a {@link GPUBindGroupDescriptor} is refused, or `null` when it is not.
+     *
+     * Only the resources' validity is asked: WebGPU requires every one of them to be "valid to use
+     * with" the device, and an invalid view — which is what `createView` gives for an invalid
+     * texture — used to be bound here without a word. What the layout additionally requires of each
+     * entry is not checked.
+     *
+     * @param {GPUBindGroupDescriptor} descriptor
+     * @returns {string|null}
+     */
+    #create_bind_group_refusal(descriptor) {
+        for (const { binding, resource } of descriptor.entries) {
+            const role = `binding ${binding}`;
+
+            const view_refusal = texture_view_resource_refusal(resource, role);
+
+            if (view_refusal !== null) {
+                return view_refusal;
+            }
+
+            // bound as itself, or through a GPUBufferBinding
+            const buffer = resource?.isSoftwareGPUBuffer === true ? resource : resource?.buffer;
+
+            if (buffer?.isSoftwareGPUBuffer === true && !buffer.isValid) {
+                return `${role} is buffer '${buffer.label}', which is invalid`;
+            }
+        }
+
+        return null;
+    }
+
     /**
      * @param {GPUPipelineLayoutDescriptor} descriptor
      * @returns {GPUPipelineLayout}

package/src/shade/device/mock/SoftwareGPUPipeline.d.ts

@@ -36,6 +36,7 @@ declare class SoftwareGPUPipelineBase extends SoftwareGPUObjectBase implements G
      * @returns {GPUBindGroupLayout}
      */
     getBindGroupLayout(index: number): GPUBindGroupLayout;
+    #private;
 }
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 export {};

package/src/shade/device/mock/SoftwareGPUPipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUPipeline.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUPipeline.js"],"names":[],"mappings":"AAoDA;;GAEG;AACH,kFAFgB,iBAAiB;IAWjC;;;OAGG;IACH,sCAFU,OAAO,CAE8C;CAZ9D;AAED;;GAEG;AACH,mFAFgB,kBAAkB;IAWlC;;;OAGG;IACH,uCAFU,OAAO,CAEgD;CAZhE;AAlDD;;;;;;GAMG;AACH,+EAFgB,eAAe;IAG3B;;OAEG;IACH,wBAFW,0DAAwD,EAKlE;IADG,gBAA4B;IAGhC;;;OAGG;IACH,0BAHW,MAAM,sBAoBhB;CACJ;sCAjDqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUPipeline.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUPipeline.js"],"names":[],"mappings":"AA0DA;;GAEG;AACH,kFAFgB,iBAAiB;IAWjC;;;OAGG;IACH,sCAFU,OAAO,CAE8C;CAZ9D;AAED;;GAEG;AACH,mFAFgB,kBAAkB;IAWlC;;;OAGG;IACH,uCAFU,OAAO,CAEgD;CAZhE;AAjED;;;;;;GAMG;AACH,+EAFgB,eAAe;IAkB3B;;OAEG;IACH,wBAFW,0DAAwD,EAKlE;IADG,gBAA4B;IAGhC;;;OAGG;IACH,0BAHW,MAAM,sBAoBhB;;CACJ;sCAvDqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUPipeline.js

@@ -1,15 +1,6 @@
 import { SoftwareGPUBindGroupLayout } from "./SoftwareGPUBindGroupLayout.js";
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 
-/**
- * The layouts an `auto`-layout pipeline hands out. A real implementation derives them from the
- * shader's bindings; nothing here inspects WGSL, so each index gets one empty layout, created once
- * so repeated calls answer the same object (bind-group caches key on it).
- *
- * @type {Map<number, SoftwareGPUBindGroupLayout>}
- */
-const DERIVED_LAYOUTS = new Map();
-
 /**
  * Emulates the part of {@link GPURenderPipeline} / {@link GPUComputePipeline} a host can observe
  * without drawing: identity, and the bind group layouts it was built over. Opaque otherwise — see
@@ -18,6 +9,21 @@ const DERIVED_LAYOUTS = new Map();
  * @implements {GPUPipelineBase}
  */
 class SoftwareGPUPipelineBase extends SoftwareGPUObjectBase {
+    /**
+     * The layouts an `auto`-layout pipeline hands out. A real implementation derives them from the
+     * shader's bindings; nothing here inspects WGSL, so each index gets one empty layout, created
+     * once so repeated calls answer the same object (bind-group caches key on it).
+     *
+     * Per PIPELINE, not per module. A derived layout belongs to the pipeline that derived it, and
+     * on a real device using one device's layout with another's is a validation error — while a
+     * module-level cache handed every `auto` pipeline on every device ever constructed the same
+     * object for a given index, so the two were `===`. The test pool runs with a shared module
+     * graph and no isolation, so that map also carried state between spec files.
+     *
+     * @type {Map<number, SoftwareGPUBindGroupLayout>}
+     */
+    #derived_layouts = new Map();
+
     /**
      * @param {GPURenderPipelineDescriptor|GPUComputePipelineDescriptor} descriptor
      */
@@ -38,12 +44,12 @@ class SoftwareGPUPipelineBase extends SoftwareGPUObjectBase {
             return layout.bindGroupLayouts[index];
         }
 
-        let derived = DERIVED_LAYOUTS.get(index);
+        let derived = this.#derived_layouts.get(index);
 
         if (derived === undefined) {
             derived = new SoftwareGPUBindGroupLayout({ entries: [] });
 
-            DERIVED_LAYOUTS.set(index, derived);
+            this.#derived_layouts.set(index, derived);
         }
 
         return derived;

package/src/shade/device/mock/SoftwareGPUQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUQueue.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUQueue.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH,yCAFgB,QAAQ;IAYpB;;OAEG;IACH,uCAEC;IAoDD;;;;;;;;;OASG;IACH,6CALW,MAAM,QACN,YAAY,eACZ,MAAM,SACN,MAAM,QA6ChB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yDAJW,YAAY,iEAmCtB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAmEC;IAED;;;OAGG;IACH,uBAFW,0BAA0B,QA0BpC;IAED;;;;;;OAMG;IACH,uBAFa,QAAQ,SAAS,CAAC,CAI9B;;CACJ"}
+{"version":3,"file":"SoftwareGPUQueue.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUQueue.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH,yCAFgB,QAAQ;IAYpB;;OAEG;IACH,uCAEC;IAoDD;;;;;;;;;OASG;IACH,6CALW,MAAM,QACN,YAAY,eACZ,MAAM,SACN,MAAM,QA6ChB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yDAJW,YAAY,iEAmCtB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAmEC;IAED;;;OAGG;IACH,uBAFW,0BAA0B,QAmEpC;IAED;;;;;;OAMG;IACH,uBAFa,QAAQ,SAAS,CAAC,CAI9B;;CACJ"}

package/src/shade/device/mock/SoftwareGPUQueue.js

@@ -343,6 +343,47 @@ export class SoftwareGPUQueue {
             return;
         }
 
+        if (this.#device.isDestroyed) {
+            // the device's own doc says work submitted to a destroyed device is a validation error
+            // rather than an exception — a renderer shutting down races its own in-flight frames,
+            // and it must take the same path here as it does in a browser
+            this.#device.generate_error(new SoftwareGPUValidationError(
+                'submit: the device has been destroyed, nothing was executed'
+            ));
+
+            return;
+        }
+
+        for (const commandBuffer of commandBuffers) {
+            const destroyed = commandBuffer.destroyed_resource();
+
+            if (destroyed !== null) {
+                // all or nothing again: WebGPU validates a submission against what it names. A copy
+                // naming a resource already destroyed was refused while encoding, so here that is one
+                // destroyed after `finish()`; a pass's attachments, and the textures and buffers it is
+                // given, are asked about nowhere else, whenever they were destroyed
+                this.#device.generate_error(new SoftwareGPUValidationError(
+                    `submit: '${destroyed.label}' has been destroyed, nothing was executed`
+                ));
+
+                return;
+            }
+
+            const mapped = commandBuffer.mapped_buffer();
+
+            if (mapped !== null) {
+                // a mapped buffer's bytes are the caller's until unmap(), so WebGPU refuses a
+                // submission that uses one, with its mapAsync still pending or not. A copy naming a
+                // mapped buffer was refused while encoding, so here that is one mapped since; a pass
+                // is given one without complaint, and this is the only check
+                this.#device.generate_error(new SoftwareGPUValidationError(
+                    `submit: buffer '${mapped.label}' is ${mapped.mapState}, not unmapped, nothing was executed`
+                ));
+
+                return;
+            }
+        }
+
         commandBuffers.forEach(commandBuffer => {
             commandBuffer.execute();
         });

package/src/shade/device/mock/SoftwareGPURenderPassEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPURenderPassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPURenderPassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,mFAFgB,oBAAoB;IAmFhC;;;OAGG;IACH,sFAQC;IA5FD;;;;;;;;;OASG;IACH,OAFU;QAAC,QAAQ,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,EAAE,CAElR;IAEX;;;;;;OAMG;IACH,oCAAW;IAoDX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,+CAIC;IAED;;;;;;;;OAQG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QAWhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,sBALW,MAAM,8BAEN,MAAM,SACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,yEAHW,MAAM,SACN,MAAM,QAMhB;IAED;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,aACN,MAAM,aACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAMhB;IAED;;OAEG;IACH,wCAIC;IADG,yBAA2B;IAG/B;;OAEG;IACH,+BAFW,MAAM,QAMhB;IADG,0BAAkC;IAwCtC;;;OAGG;IACH,mBAHW,MAAM,mBACN,MAAM,QAahB;IAED;;;OAGG;IACH,yBAHW,MAAM,mBACN,MAAM,QAahB;IAED;;;OAGG;IACH,0DAFW,MAAM,QAgBhB;IAED;;;OAGG;IACH,iEAFW,MAAM,QAehB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,yCAFU,OAAO,CAEoD;;CANpE;sCAjXqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPURenderPassEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPURenderPassEncoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,mFAFgB,oBAAoB;IAmFhC;;;OAGG;IACH,sFAQC;IA5FD;;;;;;;;;OASG;IACH,OAFU;QAAC,QAAQ,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW,EAAE,cAAc,CAAC;QAAC,eAAe,EAAE,MAAM,EAAE,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,EAAE,CAElR;IAEX;;;;;;OAMG;IACH,oCAAW;IAoDX;;;;OAIG;IACH,uBAEC;IAsBD;;OAEG;IACH,+CAIC;IAED;;;;;;;;OAQG;IACH,oBANW,MAAM,8CAEN,MAAM,EAAE,GAAC,WAAW,0BACpB,MAAM,2BACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,4BALW,MAAM,QACN,WAAW,GAAC,eAAe,gBAC3B,MAAM,cACN,MAAM,QAUhB;IAED;;;;;OAKG;IACH,sBALW,MAAM,8BAEN,MAAM,SACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,yEAHW,MAAM,SACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,aACN,MAAM,aACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAMhB;IAED;;OAEG;IACH,wCAIC;IADG,yBAA2B;IAG/B;;OAEG;IACH,+BAFW,MAAM,QAMhB;IADG,0BAAkC;IAwCtC;;;OAGG;IACH,mBAHW,MAAM,mBACN,MAAM,QAahB;IAED;;;OAGG;IACH,yBAHW,MAAM,mBACN,MAAM,QAahB;IAED;;;OAGG;IACH,0DAFW,MAAM,QAkBhB;IAED;;;OAGG;IACH,iEAFW,MAAM,QAiBhB;IAED;;OAEG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAED,YAQC;IAGL;;;OAGG;IACH,yCAFU,OAAO,CAEoD;;CANpE;sCAzYqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPURenderPassEncoder.js

@@ -141,6 +141,21 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
     setBindGroup(index, bind_group, dynamic_offsets, dynamic_offsets_start, dynamic_offsets_length) {
         this.#assert_encoding();
 
+        // `null` empties the slot, which WebGPU allows. Setting a group is what puts its textures and
+        // buffers in front of the submission, drawn with or not
+        if (bind_group !== null && bind_group !== undefined) {
+            if (!bind_group.isValid) {
+                // WebGPU invalidates the pass, which invalidates the encoder when it ends
+                this.#encoder.notify_pass_validation_error(
+                    `setBindGroup: bind group '${bind_group.label}' at index ${index} is invalid`
+                );
+
+                return;
+            }
+
+            this.#encoder.notify_pass_uses([...bind_group.textures, ...bind_group.buffers]);
+        }
+
         this.#bind_groups[index] = bind_group;
         this.#dynamic_offsets[index] = normalize_dynamic_offsets(
             dynamic_offsets,
@@ -174,6 +189,9 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
     setVertexBuffer(slot, buffer, offset = 0, size) {
         this.#assert_encoding();
 
+        // `null` empties the slot, and the submission skips it
+        this.#encoder.notify_pass_uses([buffer]);
+
         this.#vertex_buffers[slot] = { buffer, offset, size };
     }
 
@@ -186,6 +204,8 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
     setIndexBuffer(buffer, index_format, offset = 0, size) {
         this.#assert_encoding();
 
+        this.#encoder.notify_pass_uses([buffer]);
+
         this.#index_buffer = { buffer, index_format, offset, size };
     }
 
@@ -312,6 +332,8 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
         this.#assert_encoding();
         this.#validate_immediates();
 
+        this.#encoder.notify_pass_uses([indirect_buffer]);
+
         this.draws.push({
             ...this.#snapshot(),
             // the counts are in a buffer a shader wrote, and nothing here executed it
@@ -332,6 +354,8 @@ export class SoftwareGPURenderPassEncoder extends SoftwareGPUObjectBase {
         this.#assert_encoding();
         this.#validate_immediates();
 
+        this.#encoder.notify_pass_uses([indirect_buffer]);
+
         this.draws.push({
             ...this.#snapshot(),
             vertex_count: -1,

package/src/shade/device/mock/SoftwareGPUTexture.d.ts

@@ -102,8 +102,18 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase implements GPUText
      */
     get_mip_data(mip?: number): ArrayBuffer;
     /**
+     * A view this texture will not give is reported through the device's error scopes and answered
+     * with an invalid view, the way {@link SoftwareGPUDevice#createTexture} answers a descriptor it
+     * will not honour.
+     *
+     * A destroyed texture still gives one. WebGPU keeps the two states apart: `createView` asks only
+     * that the texture be valid to use with its device, which a destroyed texture still is, and the
+     * conformance suite pins it — `createView` `texture_state` expects an error for an invalid
+     * texture and none for a destroyed one. What fails is a submission that uses the view; see
+     * {@link SoftwareGPUCommandBuffer#destroyed_resource}.
+     *
      * @param {GPUTextureViewDescriptor} [descriptor]
-     * @returns {GPUTextureView}
+     * @returns {GPUTextureView} invalid when the view was refused
      */
     createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
     /**

package/src/shade/device/mock/SoftwareGPUTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;OAGG;IACH,kEAqBC;IAED;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCA7OqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;;;;;;;;;;;OAaG;IACH,kEAUC;IAwCD;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCAlRqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTexture.js

@@ -206,12 +206,51 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
     }
 
     /**
+     * A view this texture will not give is reported through the device's error scopes and answered
+     * with an invalid view, the way {@link SoftwareGPUDevice#createTexture} answers a descriptor it
+     * will not honour.
+     *
+     * A destroyed texture still gives one. WebGPU keeps the two states apart: `createView` asks only
+     * that the texture be valid to use with its device, which a destroyed texture still is, and the
+     * conformance suite pins it — `createView` `texture_state` expects an error for an invalid
+     * texture and none for a destroyed one. What fails is a submission that uses the view; see
+     * {@link SoftwareGPUCommandBuffer#destroyed_resource}.
+     *
      * @param {GPUTextureViewDescriptor} [descriptor]
-     * @returns {GPUTextureView}
+     * @returns {GPUTextureView} invalid when the view was refused
      */
     createView(descriptor) {
-        if (this.#destroyed) {
-            throw new Error('createView on a destroyed texture');
+        const refusal = this.#create_view_refusal(descriptor);
+
+        if (refusal !== null) {
+            this.#device.generate_error(new SoftwareGPUValidationError(`createView: ${refusal}`));
+
+            return SoftwareGPUTextureView.invalid(this, descriptor);
+        }
+
+        return new SoftwareGPUTextureView(this, descriptor);
+    }
+
+    /**
+     * Why a {@link GPUTextureViewDescriptor} is refused, or `null` when it is not.
+     *
+     * @param {GPUTextureViewDescriptor} [descriptor]
+     * @returns {string|null}
+     */
+    #create_view_refusal(descriptor) {
+        /*
+         The first thing WebGPU asks, before anything about the descriptor: a view of a texture the
+         device refused is refused with it. That covers the view formats too — they are copied from
+         the descriptor whether or not the device accepted it, so without this a texture refused for
+         the `viewFormats` it declared would still hand out a view in one of them, and say nothing.
+        */
+        if (!this.#valid) {
+            return `texture '${this.label}' is invalid`;
+        }
+
+        // "valid to use with" its device asks that the device be valid too, and a destroyed one is not
+        if (this.#device.isDestroyed) {
+            return 'the device has been destroyed';
         }
 
         const format = descriptor?.format;
@@ -223,13 +262,11 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
          same way it fails on hardware.
         */
         if (format !== undefined && format !== this.format && !this.#view_formats.includes(format)) {
-            this.#device.generate_error(new SoftwareGPUValidationError(
-                `createView: '${format}' is neither the format of '${this.label}' (${this.format})`
-                + ` nor one of its viewFormats (${this.#view_formats.join(', ') || 'none'})`
-            ));
+            return `'${format}' is neither the format of '${this.label}' (${this.format})`
+                + ` nor one of its viewFormats (${this.#view_formats.join(', ') || 'none'})`;
         }
 
-        return new SoftwareGPUTextureView(this, descriptor);
+        return null;
     }
 
     /**

package/src/shade/device/mock/SoftwareGPUTextureView.d.ts

@@ -3,11 +3,29 @@
  * @implements {GPUTextureView}
  */
 export class SoftwareGPUTextureView extends SoftwareGPUObjectBase implements GPUTextureView {
+    /**
+     * The view a texture hands back for a `createView` it refused.
+     *
+     * @param {SoftwareGPUTexture} texture
+     * @param {GPUTextureViewDescriptor} [descriptor] as asked for, so a log can say what was wanted
+     * @returns {SoftwareGPUTextureView}
+     */
+    static invalid(texture: SoftwareGPUTexture, descriptor?: GPUTextureViewDescriptor): SoftwareGPUTextureView;
     /**
      * @param {SoftwareGPUTexture} texture
      * @param {GPUTextureViewDescriptor} [descriptor]
+     * @param {boolean} [valid] whether `texture` gave this view; see {@link isValid}
+     */
+    constructor(texture: SoftwareGPUTexture, descriptor?: GPUTextureViewDescriptor, valid?: boolean);
+    /**
+     * Whether the texture accepted the `createView` this was made by. See
+     * {@link SoftwareGPUBuffer#isValid} — WebGPU hands back a view for a `createView` it refuses,
+     * which includes every `createView` of an invalid texture, and that view fails everything that
+     * consumes it: a bind group naming it, a render pass pointed at it.
+     *
+     * @return {boolean}
      */
-    constructor(texture: SoftwareGPUTexture, descriptor?: GPUTextureViewDescriptor);
+    get isValid(): boolean;
     texture: SoftwareGPUTexture;
     /**
      * What the view was asked to be, retained so a test can read which format a texture is
@@ -21,6 +39,7 @@ export class SoftwareGPUTextureView extends SoftwareGPUObjectBase implements GPU
      * @type {boolean}
      */
     readonly isSoftwareGPUTextureView: boolean;
+    #private;
 }
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 //# sourceMappingURL=SoftwareGPUTextureView.d.ts.map

package/src/shade/device/mock/SoftwareGPUTextureView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTextureView.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTextureView.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,6EAFgB,cAAc;IAG1B;;;OAGG;IACH,gFAWC;IATG,4BAAsB;IAEtB;;;;;OAKG;IACH,qCAAkC;IAI1C;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CANxD;sCAvBqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTextureView.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTextureView.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,6EAFgB,cAAc;IAoC1B;;;;;;OAMG;IACH,oFAFa,sBAAsB,CAIlC;IA5BD;;;;OAIG;IACH,wFAFW,OAAO,EAcjB;IA7BD;;;;;;;OAOG;IACH,uBAEC;IASG,4BAAsB;IAGtB;;;;;OAKG;IACH,qCAAkC;IAe1C;;;OAGG;IACH,mCAFU,OAAO,CAEwC;;CANxD;sCAlDqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTextureView.js

@@ -5,13 +5,29 @@ import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
  * @implements {GPUTextureView}
  */
 export class SoftwareGPUTextureView extends SoftwareGPUObjectBase {
+    #valid = true;
+
+    /**
+     * Whether the texture accepted the `createView` this was made by. See
+     * {@link SoftwareGPUBuffer#isValid} — WebGPU hands back a view for a `createView` it refuses,
+     * which includes every `createView` of an invalid texture, and that view fails everything that
+     * consumes it: a bind group naming it, a render pass pointed at it.
+     *
+     * @return {boolean}
+     */
+    get isValid() {
+        return this.#valid;
+    }
+
     /**
      * @param {SoftwareGPUTexture} texture
      * @param {GPUTextureViewDescriptor} [descriptor]
+     * @param {boolean} [valid] whether `texture` gave this view; see {@link isValid}
      */
-    constructor(texture, descriptor) {
+    constructor(texture, descriptor, valid = true) {
         super(descriptor);
         this.texture = texture;
+        this.#valid = valid;
 
         /**
          * What the view was asked to be, retained so a test can read which format a texture is
@@ -21,6 +37,17 @@ export class SoftwareGPUTextureView extends SoftwareGPUObjectBase {
          */
         this.descriptor = descriptor ?? {};
     }
+
+    /**
+     * The view a texture hands back for a `createView` it refused.
+     *
+     * @param {SoftwareGPUTexture} texture
+     * @param {GPUTextureViewDescriptor} [descriptor] as asked for, so a log can say what was wanted
+     * @returns {SoftwareGPUTextureView}
+     */
+    static invalid(texture, descriptor) {
+        return new SoftwareGPUTextureView(texture, descriptor, false);
+    }
 }
 
 /**

package/src/shade/device/mock/recorded_binding_kind_mismatches.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Every bind-group entry a render pass the {@link SoftwareGPUDevice} recorded handed over whose kind —
+ * buffer, texture or sampler — is not the kind its pipeline layout declares at that binding, across
+ * every draw; plus any group count or entry count that disagrees with the layout.
+ *
+ * The one thing the frame graph cannot check and a picture will not always show: entries given to a
+ * bind group by position slide along when a binding is inserted anywhere but the end of a shader's
+ * resource list, and a sampler goes where a texture belongs. The device rejects it — "Binding entry
+ * textureView not set" — but only when that pass is first encoded on real hardware (AVBOIT ledger
+ * entry 21). The mock does not validate an entry against its layout, so a spec asks this instead,
+ * for any pass whose bindings are built by hand.
+ *
+ * Pure, and for specs: `expect(recorded_binding_kind_mismatches(pass, pipeline)).toEqual([])`.
+ *
+ * @param {object} pass a recorded render pass, with `draws[].bind_groups`
+ * @param {object} pipeline the `RenderPipelineDescriptor` it was drawn with
+ * @returns {string[]} one line per disagreement; empty when there is none
+ */
+export function recorded_binding_kind_mismatches(pass: object, pipeline: object): string[];
+//# sourceMappingURL=recorded_binding_kind_mismatches.d.ts.map

package/src/shade/device/mock/recorded_binding_kind_mismatches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorded_binding_kind_mismatches.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/recorded_binding_kind_mismatches.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;GAiBG;AACH,uDAJW,MAAM,YACN,MAAM,GACJ,MAAM,EAAE,CAwCpB"}

package/src/shade/device/mock/recorded_binding_kind_mismatches.js

@@ -0,0 +1,84 @@
+/**
+ * What kind of thing a recorded bind-group entry actually holds.
+ *
+ * @param {object} resource
+ * @returns {string} `"buffer"`, `"texture"` or `"sampler"`
+ */
+function bound_kind(resource) {
+    if (resource.buffer !== undefined) {
+        return "buffer";
+    }
+
+    // a view keeps the texture it is of; a sampler is descriptor and nothing else
+    return resource.texture !== undefined ? "texture" : "sampler";
+}
+
+/**
+ * @param {object} entry a bind group layout entry
+ * @returns {string} the kind it declares
+ */
+function declared_kind(entry) {
+    if (entry.buffer !== undefined) {
+        return "buffer";
+    }
+
+    return entry.texture !== undefined ? "texture" : "sampler";
+}
+
+/**
+ * Every bind-group entry a render pass the {@link SoftwareGPUDevice} recorded handed over whose kind —
+ * buffer, texture or sampler — is not the kind its pipeline layout declares at that binding, across
+ * every draw; plus any group count or entry count that disagrees with the layout.
+ *
+ * The one thing the frame graph cannot check and a picture will not always show: entries given to a
+ * bind group by position slide along when a binding is inserted anywhere but the end of a shader's
+ * resource list, and a sampler goes where a texture belongs. The device rejects it — "Binding entry
+ * textureView not set" — but only when that pass is first encoded on real hardware (AVBOIT ledger
+ * entry 21). The mock does not validate an entry against its layout, so a spec asks this instead,
+ * for any pass whose bindings are built by hand.
+ *
+ * Pure, and for specs: `expect(recorded_binding_kind_mismatches(pass, pipeline)).toEqual([])`.
+ *
+ * @param {object} pass a recorded render pass, with `draws[].bind_groups`
+ * @param {object} pipeline the `RenderPipelineDescriptor` it was drawn with
+ * @returns {string[]} one line per disagreement; empty when there is none
+ */
+export function recorded_binding_kind_mismatches(pass, pipeline) {
+    const layouts = pipeline.layout.bindGroupLayouts;
+
+    /** @type {string[]} */
+    const mismatches = [];
+
+    pass.draws.forEach((draw, draw_index) => {
+        const groups = draw.bind_groups;
+
+        if (groups.length !== layouts.length) {
+            mismatches.push(`draw ${draw_index}: ${groups.length} groups bound, ${layouts.length} declared`);
+        }
+
+        groups.forEach((group, index) => {
+            const layout = layouts[index];
+
+            if (layout === undefined) {
+                return;
+            }
+
+            const declared = new Map(layout.entries.map(entry => [entry.binding, declared_kind(entry)]));
+
+            if (group.entries.length !== declared.size) {
+                mismatches.push(`draw ${draw_index} group ${index}: ${group.entries.length} entries bound, ${declared.size} declared`);
+            }
+
+            for (const entry of group.entries) {
+                const actual = bound_kind(entry.resource);
+                const expected = declared.get(entry.binding);
+
+                if (actual !== expected) {
+                    mismatches.push(`draw ${draw_index} group ${index} binding ${entry.binding}: bound a ${actual}, layout declares a ${expected}`);
+                }
+            }
+        });
+    });
+
+    return mismatches;
+}

package/src/shade/device/mock/texture_copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_copy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/texture_copy.js"],"names":[],"mappings":"AA6MA;;;;;;;;;;;;;GAaG;AACH;IAP0C,cAAc;IACf,aAAa;IACZ,mBAAmB;IACpB,kBAAkB;IAC9B,IAAI;IACpB,MAAM,GAAC,IAAI,CA4DvB;AAiED;;;;;GAKG;AACH,uHAHW,MAAM,GACJ,IAAI,CA8BhB;;;;;;UA5Fa,WAAW;;;;YACX,MAAM;gBACN,MAAM;kBACN,MAAM"}
+{"version":3,"file":"texture_copy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/texture_copy.js"],"names":[],"mappings":"AAmOA;;;;;;;;;;;;;GAaG;AACH;IAP0C,cAAc;IACf,aAAa;IACZ,mBAAmB;IACpB,kBAAkB;IAC9B,IAAI;IACpB,MAAM,GAAC,IAAI,CAwEvB;AAiED;;;;;GAKG;AACH,uHAHW,MAAM,GACJ,IAAI,CAkChB;;;;;;UAhGa,WAAW;;;;YACX,MAAM;gBACN,MAAM;kBACN,MAAM"}