@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/shader/resource/ShaderResourceDescriptor.d.ts

@@ -1,8 +1,76 @@
 /**
  * Abstracts binding management for shaders
+ *
+ * One of these is both a declaration (name, kind, type and default) and a placement within a
+ * {@link ShaderResourceGroupDescriptor} ({@link binding_index}, {@link visibility}). The static
+ * factories ({@link uniform}, {@link storageBuffer}, {@link texture}, {@link storageTexture},
+ * {@link sampler}) make a declaration alone: it can be exported once, beside the data it describes,
+ * placed into groups with {@link ShaderResourceGroupDescriptor#add}, and named by the chunks that read
+ * it through {@link CodeChunk#requireResource}.
+ *
  * @see https://www.w3.org/TR/WGSL/#resource
  */
 export class ShaderResourceDescriptor {
+    /**
+     * @param {string} name
+     * @param {WebGPUType|string} type
+     * @returns {ShaderResourceDescriptor}
+     */
+    static "__#74@#buffer"(name: string, type: WebGPUType | string): ShaderResourceDescriptor;
+    /**
+     * A uniform buffer declaration.
+     *
+     * @param {string} name
+     * @param {WebGPUType|string} _type
+     * @param {*} [default_value]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static uniform(name: string, _type: WebGPUType | string, default_value?: any): ShaderResourceDescriptor;
+    /**
+     * A storage buffer declaration.
+     *
+     * @param {string} name
+     * @param {WebGPUType} type
+     * @param {boolean} [write_enabled]
+     * @param {boolean} [transient_default] when a frame graph pass is given nothing for this binding, it binds
+     *        a transient buffer of the type's minimum binding size in its place. The buffer comes from the
+     *        frame's pool, so its contents are whatever it last held: declare this only for a binding some
+     *        variants of the shader do not read, such as one shader switch value's resource in a union of
+     *        every value's bindings. A pass that binds by hand
+     *        ({@link ShaderResourceGroupDescriptor#generateBindings}) gets no default.
+     * @returns {ShaderResourceDescriptor}
+     */
+    static storageBuffer(name: string, type: WebGPUType, write_enabled?: boolean, transient_default?: boolean): ShaderResourceDescriptor;
+    /**
+     * A sampled texture declaration.
+     *
+     * @param {string} name
+     * @param {GPUTextureSampleType} [type]
+     * @param {GPUTextureViewDimension} [dimension]
+     * @param {boolean} [multisampled]
+     * @param {ShadeTexture} [default_value]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static texture(name: string, type?: GPUTextureSampleType, dimension?: GPUTextureViewDimension, multisampled?: boolean, default_value?: ShadeTexture): ShaderResourceDescriptor;
+    /**
+     * A storage texture declaration.
+     *
+     * @param {string} name
+     * @param {GPUTextureFormat} [format]
+     * @param {GPUTextureViewDimension} [dimension]
+     * @param {GPUStorageTextureAccess} [access]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static storageTexture(name: string, format?: GPUTextureFormat, dimension?: GPUTextureViewDimension, access?: GPUStorageTextureAccess): ShaderResourceDescriptor;
+    /**
+     * A sampler declaration.
+     *
+     * @param {string} name
+     * @param {GPUSamplerBindingType} [type]
+     * @param {SamplerDescriptor} [default_value]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static sampler(name: string, type?: GPUSamplerBindingType, default_value?: SamplerDescriptor): ShaderResourceDescriptor;
     /**
      *
      * @type {string}
@@ -36,6 +104,13 @@ export class ShaderResourceDescriptor {
      * @type {ShadeTexture|ArrayBuffer|SamplerDescriptor}
      */
     default_value: ShadeTexture | ArrayBuffer | SamplerDescriptor;
+    /**
+     * Only on a storage buffer: a frame graph pass given nothing for this binding binds a transient
+     * buffer of the type's minimum binding size in its place, contents undefined. See
+     * {@link ShaderResourceGroupDescriptor#addStorageBuffer}.
+     * @type {boolean}
+     */
+    transient_default: boolean;
     /**
      * Useful shortcut for figuring out what kind of access is declared (R/W/RW)
      * @type {number|ResourceAccessKind}
@@ -57,6 +132,23 @@ export class ShaderResourceDescriptor {
      * @returns {boolean}
      */
     equals(other: ShaderResourceDescriptor): boolean;
+    /**
+     * Whether code written against this declaration can read `binding` in its place: the same name and
+     * the same WGSL type, with at least the access this declares. A read-only storage buffer is
+     * satisfied by a read-write one, a `float` texture by an `unfilterable-float` one, and placement,
+     * visibility and defaults do not matter.
+     *
+     * @param {ShaderResourceDescriptor} binding
+     * @returns {boolean}
+     */
+    isSatisfiedBy(binding: ShaderResourceDescriptor): boolean;
+    /**
+     * This declaration without a placement: what {@link ShaderResourceGroupDescriptor#add} places, so the
+     * one declaration can sit in several groups at different binding indices.
+     *
+     * @returns {ShaderResourceDescriptor}
+     */
+    clone_declaration(): ShaderResourceDescriptor;
     /**
      * @readonly
      * @type {boolean}
@@ -64,13 +156,13 @@ export class ShaderResourceDescriptor {
     readonly isShaderResourceDescriptor: boolean;
 }
 export type ExternalTextureBindingLayout = import("../../../descriptor/binding/ExternalTextureBindingLayout.js").ExternalTextureBindingLayout;
-export type SamplerBindingLayout = import("../../../descriptor/binding/SamplerBindingLayout.js").SamplerBindingLayout;
-export type StorageTextureBindingLayout = import("../../../descriptor/binding/StorageTextureBindingLayout.js").StorageTextureBindingLayout;
 export type SamplerDescriptor = import("../../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor;
 export type ShadeTexture = import("../../texture/ShadeTexture.js").ShadeTexture;
 export type WebGPUType = import("../type/WebGPUType.js").WebGPUType;
 import { ResourceType } from "./ResourceType.js";
 import { BufferBindingLayout } from "../../../descriptor/binding/BufferBindingLayout.js";
 import { TextureBindingLayout } from "../../../descriptor/binding/TextureBindingLayout.js";
+import { SamplerBindingLayout } from "../../../descriptor/binding/SamplerBindingLayout.js";
+import { StorageTextureBindingLayout } from "../../../descriptor/binding/StorageTextureBindingLayout.js";
 import { BindGroupLayoutEntry } from "../../../descriptor/binding/BindGroupLayoutEntry.js";
 //# sourceMappingURL=ShaderResourceDescriptor.d.ts.map

package/src/shade/renderer/shader/resource/ShaderResourceDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceDescriptor.js"],"names":[],"mappings":"AA0DA;;;GAGG;AACH;IACI;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,eAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,MAFU,YAAY,CAEjB;IAEL;;OAEG;IACH,YAFU,iBAAe,MAAM,CAEhB;IAEf;;OAEG;IACH,mBAFU,mBAAmB,GAAC,oBAAoB,GAAC,oBAAoB,GAAC,2BAA2B,GAAC,4BAA4B,CAE9G;IAElB;;;OAGG;IACH,aAFU,UAAU,CAER;IAEZ;;;;OAIG;IACH,eAFU,YAAY,GAAC,WAAW,GAAC,iBAAiB,CAEtC;IAGd;;;OAGG;IACH,qBAqBC;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAM/B;IAED;;;OAGG;IACH,4CAHW,iBAAe,MAAM,GACnB,oBAAoB,CAWhC;IAED;;;;OAIG;IACH,cAHW,wBAAwB,GACtB,OAAO,CA0CnB;IAGL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;CAN5D;2CAlMY,OAAO,6DAA6D,EAAE,4BAA4B;mCAClG,OAAO,qDAAqD,EAAE,oBAAoB;0CAClF,OAAO,4DAA4D,EAAE,2BAA2B;gCAChG,OAAO,kDAAkD,EAAE,iBAAiB;2BAC5E,OAAO,+BAA+B,EAAE,YAAY;yBACpD,OAAO,uBAAuB,EAAE,UAAU;6BAR1B,mBAAmB;oCAFZ,oDAAoD;qCACnD,qDAAqD;qCAFrD,qDAAqD"}
+{"version":3,"file":"ShaderResourceDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceDescriptor.js"],"names":[],"mappings":"AAyFA;;;;;;;;;;;GAWG;AACH;IAiNI;;;;OAIG;IACH,6BAJW,MAAM,QACN,UAAU,GAAC,MAAM,GACf,wBAAwB,CAwBpC;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,SACN,UAAU,GAAC,MAAM,wBAEf,wBAAwB,CAmCpC;IAED;;;;;;;;;;;;;OAaG;IACH,2BAXW,MAAM,QACN,UAAU,kBACV,OAAO,sBACP,OAAO,GAML,wBAAwB,CAkBpC;IAED;;;;;;;;;OASG;IACH,qBAPW,MAAM,mFAGN,OAAO,kBACP,YAAY,GACV,wBAAwB,CA4CpC;IAED;;;;;;;;OAQG;IACH,4BANW,MAAM,qGAIJ,wBAAwB,CAuBpC;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,gDAEN,iBAAiB,GACf,wBAAwB,CA0BpC;IA9aD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,eAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,MAFU,YAAY,CAEjB;IAEL;;OAEG;IACH,YAFU,iBAAe,MAAM,CAEhB;IAEf;;OAEG;IACH,mBAFU,mBAAmB,GAAC,oBAAoB,GAAC,oBAAoB,GAAC,2BAA2B,GAAC,4BAA4B,CAE9G;IAElB;;;OAGG;IACH,aAFU,UAAU,CAER;IAEZ;;;;OAIG;IACH,eAFU,YAAY,GAAC,WAAW,GAAC,iBAAiB,CAEtC;IAEd;;;;;OAKG;IACH,mBAFU,OAAO,CAES;IAG1B;;;OAGG;IACH,qBAqBC;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAM/B;IAED;;;OAGG;IACH,4CAHW,iBAAe,MAAM,GACnB,oBAAoB,CAWhC;IAED;;;;OAIG;IACH,cAHW,wBAAwB,GACtB,OAAO,CA0CnB;IAED;;;;;;;;OAQG;IACH,uBAHW,wBAAwB,GACtB,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,qBAFa,wBAAwB,CAapC;IAmOL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;CAN5D;2CArgBY,OAAO,6DAA6D,EAAE,4BAA4B;gCAClG,OAAO,kDAAkD,EAAE,iBAAiB;2BAC5E,OAAO,+BAA+B,EAAE,YAAY;yBACpD,OAAO,uBAAuB,EAAE,UAAU;6BAN1B,mBAAmB;oCAVZ,oDAAoD;qCAGnD,qDAAqD;qCAFrD,qDAAqD;4CAC9C,4DAA4D;qCAHnE,qDAAqD"}

package/src/shade/renderer/shader/resource/ShaderResourceDescriptor.js

@@ -2,13 +2,19 @@ import { assert } from "../../../../core/assert.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { BindGroupLayoutEntry } from "../../../descriptor/binding/BindGroupLayoutEntry.js";
 import { BufferBindingLayout } from "../../../descriptor/binding/BufferBindingLayout.js";
+import { SamplerBindingLayout } from "../../../descriptor/binding/SamplerBindingLayout.js";
+import { StorageTextureBindingLayout } from "../../../descriptor/binding/StorageTextureBindingLayout.js";
 import { TextureBindingLayout } from "../../../descriptor/binding/TextureBindingLayout.js";
+import {
+    wgsl_texture_declaration_by_sample_type
+} from "../../texture/format/wgsl_texture_declaration_by_sample_type.js";
+import { parse_wgsl_type } from "../type/parse_wgsl_type.js";
+import { write_gpu_typed_buffer } from "../type/serde/write_gpu_typed_buffer.js";
+import { type_has_atomics } from "../type/type_has_atomics.js";
 import { ResourceType } from "./ResourceType.js";
 
 /**
  * @typedef {import("../../../descriptor/binding/ExternalTextureBindingLayout.js").ExternalTextureBindingLayout} ExternalTextureBindingLayout
- * @typedef {import("../../../descriptor/binding/SamplerBindingLayout.js").SamplerBindingLayout} SamplerBindingLayout
- * @typedef {import("../../../descriptor/binding/StorageTextureBindingLayout.js").StorageTextureBindingLayout} StorageTextureBindingLayout
  * @typedef {import("../../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor} SamplerDescriptor
  * @typedef {import("../../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
  * @typedef {import("../type/WebGPUType.js").WebGPUType} WebGPUType
@@ -56,8 +62,41 @@ function compute_storage_texture_access(access) {
     }
 }
 
+/**
+ * Whether a buffer bound as `bound` declares the address space `required` was written against:
+ * `uniform`, or `storage` with either access.
+ *
+ * @param {GPUBufferBindingType} required
+ * @param {GPUBufferBindingType} bound
+ * @returns {boolean}
+ */
+function buffer_address_space_matches(required, bound) {
+    return (required === "uniform") === (bound === "uniform");
+}
+
+/**
+ * Whether textures of these sample types are one WGSL type: `float` and `unfilterable-float` are both
+ * `f32` and differ only in the layout, while `depth` is a `texture_depth_*` of its own.
+ *
+ * @param {GPUTextureSampleType} required
+ * @param {GPUTextureSampleType} bound
+ * @returns {boolean}
+ */
+function texture_sample_type_matches(required, bound) {
+    return (required === "depth") === (bound === "depth")
+        && wgsl_texture_declaration_by_sample_type(required) === wgsl_texture_declaration_by_sample_type(bound);
+}
+
 /**
  * Abstracts binding management for shaders
+ *
+ * One of these is both a declaration (name, kind, type and default) and a placement within a
+ * {@link ShaderResourceGroupDescriptor} ({@link binding_index}, {@link visibility}). The static
+ * factories ({@link uniform}, {@link storageBuffer}, {@link texture}, {@link storageTexture},
+ * {@link sampler}) make a declaration alone: it can be exported once, beside the data it describes,
+ * placed into groups with {@link ShaderResourceGroupDescriptor#add}, and named by the chunks that read
+ * it through {@link CodeChunk#requireResource}.
+ *
  * @see https://www.w3.org/TR/WGSL/#resource
  */
 export class ShaderResourceDescriptor {
@@ -101,6 +140,14 @@ export class ShaderResourceDescriptor {
      */
     default_value;
 
+    /**
+     * Only on a storage buffer: a frame graph pass given nothing for this binding binds a transient
+     * buffer of the type's minimum binding size in its place, contents undefined. See
+     * {@link ShaderResourceGroupDescriptor#addStorageBuffer}.
+     * @type {boolean}
+     */
+    transient_default = false;
+
 
     /**
      * Useful shortcut for figuring out what kind of access is declared (R/W/RW)
@@ -200,6 +247,290 @@ export class ShaderResourceDescriptor {
         // all good
         return true;
     }
+
+    /**
+     * Whether code written against this declaration can read `binding` in its place: the same name and
+     * the same WGSL type, with at least the access this declares. A read-only storage buffer is
+     * satisfied by a read-write one, a `float` texture by an `unfilterable-float` one, and placement,
+     * visibility and defaults do not matter.
+     *
+     * @param {ShaderResourceDescriptor} binding
+     * @returns {boolean}
+     */
+    isSatisfiedBy(binding) {
+        if (this.name !== binding.name || this.type !== binding.type) {
+            return false;
+        }
+
+        const access = this.access;
+
+        if ((binding.access & access) !== access) {
+            return false;
+        }
+
+        const required = this.member_descriptor;
+        const bound = binding.member_descriptor;
+
+        switch (this.type) {
+            case ResourceType.Buffer:
+                return buffer_address_space_matches(required.type, bound.type)
+                    && this.buffer_type.equals(binding.buffer_type);
+            case ResourceType.Texture:
+                return texture_sample_type_matches(required.sampleType, bound.sampleType)
+                    && required.viewDimension === bound.viewDimension
+                    && required.multisampled === bound.multisampled;
+            case ResourceType.StorageTexture:
+                return required.format === bound.format
+                    && required.viewDimension === bound.viewDimension;
+            case ResourceType.Sampler:
+                return (required.type === "comparison") === (bound.type === "comparison");
+            default:
+                return required.equals(bound);
+        }
+    }
+
+    /**
+     * This declaration without a placement: what {@link ShaderResourceGroupDescriptor#add} places, so the
+     * one declaration can sit in several groups at different binding indices.
+     *
+     * @returns {ShaderResourceDescriptor}
+     */
+    clone_declaration() {
+        const r = new ShaderResourceDescriptor();
+
+        r.name = this.name;
+        r.type = this.type;
+        r.member_descriptor = this.member_descriptor;
+        r.buffer_type = this.buffer_type;
+        r.default_value = this.default_value;
+        r.transient_default = this.transient_default;
+
+        return r;
+    }
+
+    /**
+     * @param {string} name
+     * @param {WebGPUType|string} type
+     * @returns {ShaderResourceDescriptor}
+     */
+    static #buffer(name, type) {
+        assert.isString(name, 'name');
+        assert.defined(type, 'type');
+
+        const resource = new ShaderResourceDescriptor();
+
+        resource.name = name;
+        resource.type = ResourceType.Buffer;
+
+        let _type = type;
+
+        if (typeof type === "string") {
+            _type = parse_wgsl_type(type);
+        } else {
+
+            assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
+
+        }
+
+        resource.buffer_type = _type;
+
+        return resource;
+    }
+
+    /**
+     * A uniform buffer declaration.
+     *
+     * @param {string} name
+     * @param {WebGPUType|string} _type
+     * @param {*} [default_value]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static uniform(name, _type, default_value = undefined) {
+        assert.isString(name, 'name');
+
+        let type = _type;
+        if (typeof type === "string") {
+            type = parse_wgsl_type(type);
+        } else {
+            assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
+        }
+
+        if (type.runtime_sized) {
+            // TODO check if this is true, I don't remember exact details from the spec
+            throw new Error(`Uniforms can not use runtime sized structures. Size must be defined ahead of time. name='${name}', type=${type}`);
+        }
+
+        // https://www.w3.org/TR/WGSL/#atomic-type
+        assert.equal(type_has_atomics(type), false, 'atomics are not allowed in uniforms');
+
+        const resource = ShaderResourceDescriptor.#buffer(name, type);
+
+        resource.member_descriptor = BufferBindingLayout.uniform;
+
+        if (default_value !== undefined) {
+
+            const buffer = new ArrayBuffer(type.size);
+
+            write_gpu_typed_buffer(default_value, resource.buffer_type, buffer, 0);
+
+            resource.default_value = buffer;
+
+        }
+
+        return resource;
+    }
+
+    /**
+     * A storage buffer declaration.
+     *
+     * @param {string} name
+     * @param {WebGPUType} type
+     * @param {boolean} [write_enabled]
+     * @param {boolean} [transient_default] when a frame graph pass is given nothing for this binding, it binds
+     *        a transient buffer of the type's minimum binding size in its place. The buffer comes from the
+     *        frame's pool, so its contents are whatever it last held: declare this only for a binding some
+     *        variants of the shader do not read, such as one shader switch value's resource in a union of
+     *        every value's bindings. A pass that binds by hand
+     *        ({@link ShaderResourceGroupDescriptor#generateBindings}) gets no default.
+     * @returns {ShaderResourceDescriptor}
+     */
+    static storageBuffer(name, type, write_enabled = false, transient_default = false) {
+        assert.defined(type, 'type');
+        assert.isBoolean(write_enabled, 'write_enabled');
+        assert.isBoolean(transient_default, 'transient_default');
+        assert.isObject(type, 'type');
+        assert.equal(type.isWebGPUType, true, 'type.isWebGPUType !== true');
+
+        // https://www.w3.org/TR/WGSL/#atomic-type
+        assert.equal(type_has_atomics(type) && !write_enabled, false, 'atomics are only allowed in write-access mode');
+
+        const resource = ShaderResourceDescriptor.#buffer(name, type);
+
+        resource.member_descriptor = write_enabled ? BufferBindingLayout.storage : BufferBindingLayout.readOnlyStorage;
+        resource.transient_default = transient_default;
+
+        return resource;
+    }
+
+    /**
+     * A sampled texture declaration.
+     *
+     * @param {string} name
+     * @param {GPUTextureSampleType} [type]
+     * @param {GPUTextureViewDimension} [dimension]
+     * @param {boolean} [multisampled]
+     * @param {ShadeTexture} [default_value]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static texture(
+        name,
+        type = "unfilterable-float",
+        dimension = "2d",
+        multisampled = false,
+        default_value = undefined,
+    ) {
+        assert.isString(name, 'name');
+        assert.isOneOf(type, [
+            "unfilterable-float",
+            "float",
+            "sint",
+            "uint",
+            "depth"
+        ], 'type');
+
+        assert.isOneOf(dimension, [
+            "1d",
+            "2d",
+            "2d-array",
+            "cube",
+            "cube-array",
+            "3d"
+        ], "dimension");
+
+        const resource = new ShaderResourceDescriptor();
+
+        resource.name = name;
+        resource.type = ResourceType.Texture;
+        resource.member_descriptor = TextureBindingLayout.fromJSON({
+            sampleType: type,
+            viewDimension: dimension,
+            multisampled
+        });
+
+        if (default_value !== undefined) {
+            assert.equal(default_value.isShadeTexture, true, 'default_value.isShadeTexture !== true');
+
+            resource.default_value = default_value;
+        }
+
+        return resource;
+    }
+
+    /**
+     * A storage texture declaration.
+     *
+     * @param {string} name
+     * @param {GPUTextureFormat} [format]
+     * @param {GPUTextureViewDimension} [dimension]
+     * @param {GPUStorageTextureAccess} [access]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static storageTexture(
+        name,
+        format,
+        dimension,
+        access
+    ) {
+
+        assert.isString(name, 'name');
+
+        const resource = new ShaderResourceDescriptor();
+
+        resource.name = name;
+        resource.type = ResourceType.StorageTexture;
+
+        resource.member_descriptor = StorageTextureBindingLayout.fromJSON({
+            format,
+            access,
+            viewDimension: dimension
+        });
+
+        return resource;
+    }
+
+    /**
+     * A sampler declaration.
+     *
+     * @param {string} name
+     * @param {GPUSamplerBindingType} [type]
+     * @param {SamplerDescriptor} [default_value]
+     * @returns {ShaderResourceDescriptor}
+     */
+    static sampler(name, type = "filtering", default_value = undefined) {
+        assert.isString(name, 'name');
+        assert.isOneOf(type, ["filtering", "non-filtering", "comparison"])
+
+
+        const resource = new ShaderResourceDescriptor();
+
+        resource.name = name;
+        resource.type = ResourceType.Sampler;
+
+        resource.member_descriptor = SamplerBindingLayout.fromJSON({
+            type
+        });
+
+        if (default_value !== undefined) {
+            assert.isObject(default_value, 'default_value');
+            assert.equal(default_value.isSamplerDescriptor, true, 'default_value.isSamplerDescriptor !== true');
+
+            // TODO validate that type matches
+
+            resource.default_value = default_value;
+        }
+
+        return resource;
+    }
 }
 
 /**

package/src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.d.ts

@@ -48,6 +48,14 @@ export class ShaderResourceGroupDescriptor {
      * @returns {ShaderResourceDescriptor|undefined}
      */
     get(name: string): ShaderResourceDescriptor | undefined;
+    /**
+     * Place `declaration` in this group, at the first free binding index. The group holds a copy, so
+     * the one declaration, exported beside the data it describes, can be placed in any number of groups.
+     *
+     * @param {ShaderResourceDescriptor} declaration see {@link ShaderResourceDescriptor.uniform} and its siblings
+     * @returns {this}
+     */
+    add(declaration: ShaderResourceDescriptor): this;
     /**
      *
      * @param {string} name
@@ -61,9 +69,14 @@ export class ShaderResourceGroupDescriptor {
      * @param {string} name
      * @param {WebGPUType} type
      * @param {boolean} [write_enabled]
+     * @param {boolean} [transient_default] when a frame graph pass is given nothing for this binding, it binds
+     *        a transient buffer of the type's minimum binding size in its place. The buffer comes from the
+     *        frame's pool, so its contents are whatever it last held: declare this only for a binding some
+     *        variants of the shader do not read, such as one shader switch value's resource in a union of
+     *        every value's bindings. A pass that binds by hand ({@link generateBindings}) gets no default.
      * @returns {this}
      */
-    addStorageBuffer(name: string, type: WebGPUType, write_enabled?: boolean): this;
+    addStorageBuffer(name: string, type: WebGPUType, write_enabled?: boolean, transient_default?: boolean): this;
     /**
      *
      * @param {string} name

package/src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceGroupDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js"],"names":[],"mappings":"AAqCA;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAQV;;OAEG;IACH,4CAEC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,CAkJhC;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAc/B;IAED;;;;OAIG;IACH,6CAFa,mBAAmB,CA6B/B;IAED;;;OAGG;IACH,mDAHW,iBAAe,MAAM,GACnB,yBAAyB,CAqBrC;IAED;;;OAGG;IACH,gBAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,WAHW,MAAM,YACN,wBAAwB,QAUlC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,wBAAwB,GAAC,SAAS,CAiB9C;IAqDD;;;;;;OAMG;IACH,iBALW,MAAM,SACN,UAAU,GAAC,MAAM,wBAEf,IAAI,CAqChB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,QACN,UAAU,kBACV,OAAO,GACL,IAAI,CAmBhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,mFAGN,OAAO,kBACP,YAAY,GACV,IAAI,CA8ChB;IAED;;;;;;;OAOG;IACH,wBANW,MAAM,qGAIL,6BAA6B,CAyBxC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,gDAEN,iBAAiB,GACf,6BAA6B,CA4BzC;;CAEJ;gCAvjBY,OAAO,kDAAkD,EAAE,iBAAiB;qCAC5E,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,+BAA+B,EAAE,YAAY;yBACpD,OAAO,uBAAuB,EAAE,UAAU;yCANd,+BAA+B;0CAV9B,0DAA0D"}
+{"version":3,"file":"ShaderResourceGroupDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceGroupDescriptor.js"],"names":[],"mappings":"AA8BA;IAEI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAQV;;OAEG;IACH,4CAEC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,CA0JhC;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAc/B;IAED;;;;OAIG;IACH,6CAFa,mBAAmB,CA6B/B;IAED;;;OAGG;IACH,mDAHW,iBAAe,MAAM,GACnB,yBAAyB,CAqBrC;IAED;;;OAGG;IACH,gBAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,WAHW,MAAM,YACN,wBAAwB,QAUlC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,wBAAwB,GAAC,SAAS,CAiB9C;IAuBD;;;;;;OAMG;IACH,iBAHW,wBAAwB,GACtB,IAAI,CAShB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,UAAU,GAAC,MAAM,wBAEf,IAAI,CAMhB;IAED;;;;;;;;;;;OAWG;IACH,uBAVW,MAAM,QACN,UAAU,kBACV,OAAO,sBACP,OAAO,GAKL,IAAI,CAMhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,mFAGN,OAAO,kBACP,YAAY,GACV,IAAI,CAYhB;IAED;;;;;;;OAOG;IACH,wBANW,MAAM,qGAIL,6BAA6B,CAWxC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,gDAEN,iBAAiB,GACf,6BAA6B,CAMzC;;CAEJ;gCApcY,OAAO,kDAAkD,EAAE,iBAAiB;qCAC5E,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,+BAA+B,EAAE,YAAY;yBACpD,OAAO,uBAAuB,EAAE,UAAU;yCANd,+BAA+B;0CAH9B,0DAA0D"}