@woosh/meep-engine 3.11.3 → 3.13.0

package/src/shade/renderer/shader/pass/RenderPassDescriptor.js

@@ -1,190 +1,190 @@
-import { assert } from "../../../../core/assert.js";
-import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
-import { RenderPassDepthStencilAttachmentDescriptor } from "./RenderPassDepthStencilAttachmentDescriptor.js";
-
-/**
- * {@link GPURenderPassDescriptor}
- */
-export class RenderPassDescriptor {
-    /**
-     * @type {RenderPipelineDescriptor}
-     */
-    pipeline
-
-    /**
-     * @type {ShaderResourceSetDescriptor}
-     */
-    resources
-
-    /**
-     *
-     * @type {RenderPassColorAttachmentDescriptor[]}
-     */
-    colorAttachments = [];
-
-    /**
-     *
-     * @type {RenderPassDepthStencilAttachmentDescriptor}
-     */
-    depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
-
-
-    /**
-     * @param {GPUTextureContext[]} [colorTargets]
-     * @param {GPUTextureContext} [depthTarget]
-     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
-     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
-     * @param {GPULoadOp} [colorLoadOp] defaults to `loadOp`
-     * @param {GPUStoreOp} [colorStoreOp] defaults to `storeOp`
-     * @param {GPULoadOp} [depthLoadOp] defaults to `loadOp`
-     * @param {GPUStoreOp} [depthStoreOp] defaults to `storeOp`
-     * @returns {GPURenderPassDescriptor}
-     */
-    toGPU({
-              colorTargets = [],
-              depthTarget,
-              loadOp = "clear",
-              storeOp = "store",
-              colorLoadOp = loadOp,
-              colorStoreOp = storeOp,
-              depthLoadOp = loadOp,
-              depthStoreOp = storeOp,
-          }) {
-
-        assert.defined(colorTargets, 'colorAttachments');
-        assert.isArray(colorTargets, 'colorAttachments');
-
-        assert.isOneOf(loadOp, ['clear', 'load'], 'loadOp');
-        assert.isOneOf(storeOp, ['store', 'discard'], 'storeOp');
-
-
-        assert.isOneOf(colorLoadOp, ['clear', 'load'], 'colorLoadOp');
-        assert.isOneOf(colorStoreOp, ['store', 'discard'], 'colorStoreOp');
-
-        assert.isOneOf(depthLoadOp, ['clear', 'load'], 'depthLoadOp');
-        assert.isOneOf(depthStoreOp, ['store', 'discard'], 'depthStoreOp');
-
-        const _colorAttachments = [];
-
-        const color_target_count = colorTargets.length;
-        for (let i = 0; i < color_target_count; i++) {
-            const texture = colorTargets[i];
-
-            assert.defined(texture, 'texture');
-            assert.isObject(texture, 'texture');
-            assert.equal(texture.isGPUTextureContext, true, 'texture.isGPUTextureContext !== true');
-
-            const descriptor = this.colorAttachments[i];
-            _colorAttachments[i] = {
-                view: texture.obtainView(descriptor.view),
-                clearValue: descriptor.clearValue,
-                loadOp: colorLoadOp,
-                storeOp: colorStoreOp,
-            };
-        }
-
-        const depthDescriptor = this.depthStencilAttachment;
-
-
-        let _depthStencilAttachment;
-
-        if (depthTarget !== undefined) {
-            assert.equal(depthTarget.isGPUTextureContext, true, 'depthTarget.isGPUTextureContext !== true')
-
-            _depthStencilAttachment = {
-                view: depthTarget.obtainView(depthDescriptor.view),
-                depthClearValue: depthDescriptor.depthClearValue,
-                depthLoadOp: depthLoadOp,
-                depthStoreOp: depthStoreOp,
-            };
-
-        } else {
-
-            // no depth
-
-        }
-
-        return {
-            label: this.pipeline.label,
-            colorAttachments: _colorAttachments,
-            depthStencilAttachment: _depthStencilAttachment,
-        };
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUTextureContext[]} [colorTargets]
-     * @param {GPUTextureContext} [depthTarget]
-     * @param {Object} [bindings]
-     * @param {PrimitiveState} [primitive_state]
-     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
-     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
-     * @returns {GPURenderPassEncoder}
-     */
-    begin({
-              encoder,
-              colorTargets = [],
-              depthTarget,
-              bindings = {},
-        primitive_state,
-              loadOp = "clear",
-              storeOp = "store",
-          }) {
-        assert.defined(encoder, 'encoder');
-
-        assert.defined(bindings, 'bindings');
-        assert.isObject(bindings, 'bindings');
-
-        const gpu_descriptor = this.toGPU({
-            colorTargets,
-            depthTarget,
-            loadOp,
-            storeOp,
-        });
-
-        let pipeline = this.pipeline;
-
-        if(primitive_state !== undefined){
-            pipeline = rp_rewrite_for_primitive_state(pipeline,primitive_state);
-        }
-
-        return encoder.constructRenderPass({
-            pipeline,
-            bindings: this.resources.generateBindings(bindings),
-            immediate: encoder.writeImmediate(this.resources, bindings),
-            colorAttachments: gpu_descriptor.colorAttachments,
-            depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
-        });
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUBuffer} command See {@link STRUCT_UNINDEXED_DRAW_COMMAND}
-     * @param {number} [command_offset]
-     * @param {Object} [bindings]
-     * @param {RenderTarget} render_target
-     */
-    drawIndirect({
-                     encoder,
-                     command,
-                     command_offset = 0,
-                     bindings = {},
-                     render_target
-                 }) {
-
-        const pass = this.begin({ encoder: encoder, render_target: render_target, bindings: bindings });
-
-        pass.drawIndirect(command, command_offset);
-
-        pass.end();
-
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
+import { assert } from "../../../../core/assert.js";
+import { rp_rewrite_for_primitive_state } from "../../../device/pipeline/rp_rewrite_for_primitive_state.js";
+import { RenderPassDepthStencilAttachmentDescriptor } from "./RenderPassDepthStencilAttachmentDescriptor.js";
+
+/**
+ * {@link GPURenderPassDescriptor}
+ */
+export class RenderPassDescriptor {
+    /**
+     * @type {RenderPipelineDescriptor}
+     */
+    pipeline
+
+    /**
+     * @type {ShaderResourceSetDescriptor}
+     */
+    resources
+
+    /**
+     *
+     * @type {RenderPassColorAttachmentDescriptor[]}
+     */
+    colorAttachments = [];
+
+    /**
+     *
+     * @type {RenderPassDepthStencilAttachmentDescriptor}
+     */
+    depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
+
+
+    /**
+     * @param {GPUTextureContext[]} [colorTargets]
+     * @param {GPUTextureContext} [depthTarget]
+     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
+     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
+     * @param {GPULoadOp} [colorLoadOp] defaults to `loadOp`
+     * @param {GPUStoreOp} [colorStoreOp] defaults to `storeOp`
+     * @param {GPULoadOp} [depthLoadOp] defaults to `loadOp`
+     * @param {GPUStoreOp} [depthStoreOp] defaults to `storeOp`
+     * @returns {GPURenderPassDescriptor}
+     */
+    toGPU({
+              colorTargets = [],
+              depthTarget,
+              loadOp = "clear",
+              storeOp = "store",
+              colorLoadOp = loadOp,
+              colorStoreOp = storeOp,
+              depthLoadOp = loadOp,
+              depthStoreOp = storeOp,
+          }) {
+
+        assert.defined(colorTargets, 'colorAttachments');
+        assert.isArray(colorTargets, 'colorAttachments');
+
+        assert.isOneOf(loadOp, ['clear', 'load'], 'loadOp');
+        assert.isOneOf(storeOp, ['store', 'discard'], 'storeOp');
+
+
+        assert.isOneOf(colorLoadOp, ['clear', 'load'], 'colorLoadOp');
+        assert.isOneOf(colorStoreOp, ['store', 'discard'], 'colorStoreOp');
+
+        assert.isOneOf(depthLoadOp, ['clear', 'load'], 'depthLoadOp');
+        assert.isOneOf(depthStoreOp, ['store', 'discard'], 'depthStoreOp');
+
+        const _colorAttachments = [];
+
+        const color_target_count = colorTargets.length;
+        for (let i = 0; i < color_target_count; i++) {
+            const texture = colorTargets[i];
+
+            assert.defined(texture, 'texture');
+            assert.isObject(texture, 'texture');
+            assert.equal(texture.isGPUTextureContext, true, 'texture.isGPUTextureContext !== true');
+
+            const descriptor = this.colorAttachments[i];
+            _colorAttachments[i] = {
+                view: texture.obtainView(descriptor.view),
+                clearValue: descriptor.clearValue,
+                loadOp: colorLoadOp,
+                storeOp: colorStoreOp,
+            };
+        }
+
+        const depthDescriptor = this.depthStencilAttachment;
+
+
+        let _depthStencilAttachment;
+
+        if (depthTarget !== undefined) {
+            assert.equal(depthTarget.isGPUTextureContext, true, 'depthTarget.isGPUTextureContext !== true')
+
+            _depthStencilAttachment = {
+                view: depthTarget.obtainView(depthDescriptor.view),
+                depthClearValue: depthDescriptor.depthClearValue,
+                depthLoadOp: depthLoadOp,
+                depthStoreOp: depthStoreOp,
+            };
+
+        } else {
+
+            // no depth
+
+        }
+
+        return {
+            label: this.pipeline.label,
+            colorAttachments: _colorAttachments,
+            depthStencilAttachment: _depthStencilAttachment,
+        };
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUTextureContext[]} [colorTargets]
+     * @param {GPUTextureContext} [depthTarget]
+     * @param {Object} [bindings]
+     * @param {PrimitiveState} [primitive_state]
+     * @param {GPULoadOp} [loadOp="clear"] Used for both color targets and depth target
+     * @param {GPUStoreOp} [storeOp="store"] Used for both color targets and depth target
+     * @returns {ShadeGPURenderPassEncoder}
+     */
+    begin({
+              encoder,
+              colorTargets = [],
+              depthTarget,
+              bindings = {},
+        primitive_state,
+              loadOp = "clear",
+              storeOp = "store",
+          }) {
+        assert.defined(encoder, 'encoder');
+
+        assert.defined(bindings, 'bindings');
+        assert.isObject(bindings, 'bindings');
+
+        const gpu_descriptor = this.toGPU({
+            colorTargets,
+            depthTarget,
+            loadOp,
+            storeOp,
+        });
+
+        let pipeline = this.pipeline;
+
+        if(primitive_state !== undefined){
+            pipeline = rp_rewrite_for_primitive_state(pipeline,primitive_state);
+        }
+
+        return encoder.constructRenderPass({
+            pipeline,
+            bindings: this.resources.generateBindings(bindings),
+            immediate: encoder.writeImmediate(this.resources, bindings),
+            colorAttachments: gpu_descriptor.colorAttachments,
+            depthStencilAttachment: gpu_descriptor.depthStencilAttachment,
+        });
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUBuffer} command See {@link STRUCT_UNINDEXED_DRAW_COMMAND}
+     * @param {number} [command_offset]
+     * @param {Object} [bindings]
+     * @param {RenderTarget} render_target
+     */
+    drawIndirect({
+                     encoder,
+                     command,
+                     command_offset = 0,
+                     bindings = {},
+                     render_target
+                 }) {
+
+        const pass = this.begin({ encoder: encoder, render_target: render_target, bindings: bindings });
+
+        pass.drawIndirect(command, command_offset);
+
+        pass.end();
+
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
 RenderPassDescriptor.prototype.isRenderPassDescriptor = true;

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

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AA8HA;IAoBI;;OAEG;IACH;cAFoB,MAAM;;MAIzB;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,aAAW,MAAM,GAEf,IAAI,CA6ChB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAEJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,8DAFa,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gDAFa,OAAO,CA0CnB;;CACJ;;eAKS,SAAS,2BAA2B,CAAC;;8CAzjBD,oCAAoC;yCAXzC,0DAA0D;0BAIzE,0BAA0B"}
+{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAgIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;;MAIzB;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,aAAW,MAAM,GAEf,IAAI,CA6ChB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAEJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,8DAFa,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gDAFa,OAAO,CA0CnB;;CACJ;;eAKS,SAAS,2BAA2B,CAAC;;8CA3jBD,oCAAoC;yCAXzC,0DAA0D;0BAIzE,0BAA0B"}

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

@@ -114,7 +114,9 @@ function gen_type_storage_texture(member) {
 function gen_type_sampler(member) {
     // see https://www.w3.org/TR/WGSL/#sampler-type
 
-    if (member.type === "filtering") {
+    // WGSL has no "non-filtering" sampler type; filtering is a bind-group-layout property, so
+    // both "filtering" and "non-filtering" declare a plain `sampler`
+    if (member.type === "filtering" || member.type === "non-filtering") {
         return "sampler";
     } else if (member.type === "comparison") {
         return "sampler_comparison";

package/src/shade/renderer/shader/util/compute_infer_workgroup_size_from_source.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Recover a compute entry point's workgroup size from its WGSL source.
+ *
+ * Follows the `workgroup_size_attr` grammar, so every spelling below is read alike, and the omitted
+ * dimensions default to `1`:
+ *
+ * ```wgsl
+ * @workgroup_size(64)              // -> [64, 1, 1]
+ * @workgroup_size(8, 8)            // -> [8, 8, 1]
+ * @workgroup_size( 8 , 8 , 4 , )   // -> [8, 8, 4], blankspace anywhere, trailing comma
+ * @workgroup_size(0x40u)           // -> [64, 1, 1], hexadecimal, and the i/u type suffixes
+ * ```
+ *
+ * An argument may also name a `const` that the same module binds directly to an integer literal,
+ * which is how a shader states its block size once and then uses it in both the attribute and the
+ * body:
+ *
+ * ```wgsl
+ * const BLOCK_DIM = 256u;
+ * @workgroup_size(BLOCK_DIM)       // -> [256, 1, 1]
+ * ```
+ *
+ * Comments count as blankspace and are removed first, so they may sit between any two tokens of the
+ * attribute, and an attribute that is itself commented out is correctly not found.
+ *
+ * **One level of aliasing, and no arithmetic.** WGSL permits any const-expression or
+ * override-expression, so `@workgroup_size(BLOCK_DIM / 2u)` is legal, and so is
+ * `@workgroup_size(WG_X)` for an `override WG_X` whose value only arrives with the pipeline.
+ * Neither is resolvable from the source text alone. Such a shader throws rather than being guessed
+ * at, because every caller for this number divides a thread count by it, and a wrong divisor
+ * silently dispatches the wrong fraction of the workload. A loud failure is recoverable; a
+ * plausible one is not.
+ *
+ * Entry points that disagree are an error for the same reason. A module may hold several, and
+ * choosing between two conflicting sizes would be choosing at random.
+ *
+ * @param {string} code WGSL source
+ * @returns {[number, number, number]} `[x, y, z]`
+ * @throws {Error} if no `@workgroup_size` attribute is present, if its arguments are neither
+ * integer literals nor names resolving to one, if a dimension is not a positive integer, or if
+ * entry points disagree on the size
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function compute_infer_workgroup_size_from_source(code: string): [number, number, number];
+//# sourceMappingURL=compute_infer_workgroup_size_from_source.d.ts.map

package/src/shade/renderer/shader/util/compute_infer_workgroup_size_from_source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_infer_workgroup_size_from_source.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/util/compute_infer_workgroup_size_from_source.js"],"names":[],"mappings":"AA2SA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,+DATW,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CA+GpC"}