@woosh/meep-engine 3.12.0 → 3.13.1

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/shadow/map/GPUSceneShadowmapContext.d.ts

@@ -81,7 +81,8 @@ export class GPUSceneShadowmapContext {
      * Runs at the top of every frame, before {@link draw}. Responsibilities:
      *
      *  1. **Reset per-frame signals.** `should_draw` is cleared on every map so a stale "yes"
-     *     from a prior frame can never cause a spurious extra raster.
+     *     from a prior frame can never cause a spurious extra raster. Folded into the selector's
+     *     scoring pass, which walks every map anyway.
      *  2. **Measure on-screen presence.** `projected_area_px` is computed once per map and stored
      *     on the map itself — consumed by the resolution policy, the scorer, and the selector,
      *     and exposed for debug tooling.
@@ -90,7 +91,8 @@ export class GPUSceneShadowmapContext {
      *     resize. The committed `layout` is left untouched so sampling remains valid; the
      *     pending is consumed later by {@link draw} when the scheduler naturally picks this map
      *     up (no forced redraw).
-     *  4. **Score + select.** For each map:
+     *  4. **Score + select.** Delegated to {@link ShadowmapDrawSelector}, which sets `should_draw`
+     *     on the winners and reports the view spend and whether any candidate went unmet:
      *        - **Directional** → always selected (infinite score); view cost still charged.
      *        - **Local, off-screen** (`projected_area_px <= 0`) → skipped entirely.
      *        - **Local, in-view, invalid** → MUST draw. `is_invalid` means the committed layout
@@ -99,15 +101,16 @@ export class GPUSceneShadowmapContext {
      *          layout model — this flag fires only on first-draw.
      *        - **Local, in-view, valid** → compete for the remaining budget by score. Ordering
      *          is descending score so the most important (largest-on-screen, stalest) maps win.
-     *  5. **Commit selection.** On each winner we set `should_draw = true` and call
-     *     `map.update()` so its projection matrices reflect the current frame. The
-     *     `last_updated_frame_index` stamp is deferred to {@link draw} — it records when the
-     *     atlas contents become current, not when the projection is fitted.
+     *  5. **Fit the winners.** `map.update()` on each selected map, so its projection matrices
+     *     reflect the current frame. The `last_updated_frame_index` stamp is deferred to
+     *     {@link draw} — it records when the atlas contents become current, not when the
+     *     projection is fitted.
      *
      * Shadow records are NOT written here; they're written at the end of {@link draw} so the
      * shader reads slots that reflect any just-committed pending swaps within the same frame.
      *
-     * See {@link compute_shadowmap_update_score} for the scoring formula and rationale.
+     * See {@link compute_shadowmap_update_score} for the scoring formula and rationale, and
+     * {@link ShadowmapDrawSelector} for why the ordering is a heap drain rather than a sort.
      *
      * @param {Camera} main_camera used both for rendering the final frame and for projected-area
      *        computation and directional CSM fit; must be callable for `.update()`
@@ -160,6 +163,12 @@ export class GPUSceneShadowmapContext {
      * {@link LightCollection.version} hasn't moved — `light.casts_shadow` flips are not
      * tracked by version and are detected here.
      *
+     * Runs as three linear passes — mark, reclaim, allocate — over {@link #registry}, which owns
+     * the light -> map index and the marks. It used to scan the map array once per light to find
+     * out whether that light already had one, which made the pass quadratic: 148us per frame at
+     * 512 lights against 19us now, and 554us against 45us at 1024. See
+     * benchmark/reconcile.spec.js.
+     *
      * @returns {boolean} true when at least one map was added/evicted or at least one light's
      *          per-type shadow_id moved. The caller uses this to decide whether the light
      *          records need to be re-published (their `shadow_id` and CASTS_SHADOW_BIT may

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAuFA;;GAEG;AACH;IA8JI;;;;;;;;OAQG;IACH,8FA0DC;IAhOD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsBpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAqCtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAgGD;;;;OAIG;IACH,uBAFa,YAAU,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,0EAJW,MAAM,mBACN,UAAU,MAAM,CAAC,QA6G3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gDAiFC;IAgbD;;;;;;;;;;;;;;OAcG;IACH,kBALa,OAAO,CAkMnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAWC;;CACJ;oCA3yCmC,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAwFA;;GAEG;AACH;IA8KI;;;;;;;;OAQG;IACH,8FA0DC;IAhPD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAqCtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAgGD;;;;OAIG;IACH,uBAFa,YAAU,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,0EAJW,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gDAiFC;IA6aD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAuOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAYC;;CACJ;oCA3zCmC,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}