@woosh/meep-engine 3.60.7 → 3.60.9

package/src/engine/network/state/ReplicationSlotTable.js

@@ -12,8 +12,9 @@ import { assert } from "../../../core/assert.js";
  * match the live `(network_id=5, generation=3)` slot, so use-after-free can
  * be detected at parse time on the receiving peer.
  *
- * Storage is two parallel typed arrays indexed by `network_id`, plus a small
- * free-list of reusable IDs. No JS object per slot.
+ * Storage is three parallel typed arrays indexed by `network_id` (entity,
+ * generation, index in the free list), plus a free-list of reusable IDs.
+ * No JS object per slot.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -28,6 +29,7 @@ export class ReplicationSlotTable {
      * @private
      */
     #free_list = [];
+    #free_position_by_network;
     /**
      * Highest network_id ever assigned.
      * @type {number}
@@ -54,6 +56,13 @@ export class ReplicationSlotTable {
          */
         this.#generation_by_network = new Uint32Array(initial_capacity);
 
+        /**
+         * Index of each network_id in `#free_list`, or -1 if it is not on it.
+         * @type {Int32Array}
+         * @private
+         */
+        this.#free_position_by_network = new Int32Array(initial_capacity).fill(-1);
+
         /**
          * Reverse map for entity_id -> network_id lookup.
          * Sparse; only populated for live mappings.
@@ -85,6 +94,7 @@ export class ReplicationSlotTable {
         let network_id;
         if (this.#free_list.length > 0) {
             network_id = this.#free_list.pop();
+            this.#free_position_by_network[network_id] = -1;
         } else {
             network_id = this.#highwater++;
             if (network_id >= this.#capacity) {
@@ -99,8 +109,10 @@ export class ReplicationSlotTable {
 
     /**
      * Allocate using an explicit network_id (for the receiving peer that takes its
-     * IDs from the wire). Bumps the slot's generation if it was reused. Throws
-     * if the slot is currently in use.
+     * IDs from the wire). The id may be one this peer freed and the sender has
+     * since recycled; it is taken off the free list, so {@link allocate} will not
+     * hand it out. The slot keeps the generation {@link free} gave it. Throws if
+     * the slot is currently in use.
      *
      * @param {number} network_id
      * @param {number} entity_id
@@ -117,9 +129,16 @@ export class ReplicationSlotTable {
         if (this.#network_id_by_entity.has(entity_id)) {
             throw new Error(`ReplicationSlotTable.allocate_at: entity ${entity_id} already has network_id ${this.#network_id_by_entity.get(entity_id)}`);
         }
-        // Catch the "id is on the free list" case before silent clobbering: a
-        // subsequent allocate() would pop the same id and overwrite this mapping.
-        assert.arrayHasNo(this.#free_list, network_id, `ReplicationSlotTable.allocate_at: network_id ${network_id} is in the free list`);
+        const free_position = this.#free_position_by_network[network_id];
+        if (free_position !== -1) {
+            // swap-remove: the last entry fills the hole
+            const last = this.#free_list.pop();
+            if (last !== network_id) {
+                this.#free_list[free_position] = last;
+                this.#free_position_by_network[last] = free_position;
+            }
+            this.#free_position_by_network[network_id] = -1;
+        }
         this.#entity_id_by_network[network_id] = entity_id;
         this.#network_id_by_entity.set(entity_id, network_id);
         if (network_id >= this.#highwater) this.#highwater = network_id + 1;
@@ -127,12 +146,16 @@ export class ReplicationSlotTable {
 
     /**
      * Free the slot for `network_id`. Bumps the slot's generation. Slot becomes
-     * available for re-allocation.
+     * available for re-allocation. Freeing a slot that is not in use, including
+     * one past the table's storage, does nothing.
      *
      * @param {number} network_id
      */
     free(network_id) {
         assert.isNonNegativeInteger(network_id, 'network_id');
+        if (network_id >= this.#capacity) {
+            return; // never allocated
+        }
         const entity_id = this.#entity_id_by_network[network_id];
         if (entity_id === -1) {
             return; // already free
@@ -140,6 +163,7 @@ export class ReplicationSlotTable {
         this.#entity_id_by_network[network_id] = -1;
         this.#network_id_by_entity.delete(entity_id);
         this.#generation_by_network[network_id] = (this.#generation_by_network[network_id] + 1) >>> 0;
+        this.#free_position_by_network[network_id] = this.#free_list.length;
         this.#free_list.push(network_id);
     }
 
@@ -199,8 +223,12 @@ export class ReplicationSlotTable {
         const new_generations = new Uint32Array(new_capacity);
         new_generations.set(this.#generation_by_network);
 
+        const new_free_positions = new Int32Array(new_capacity).fill(-1);
+        new_free_positions.set(this.#free_position_by_network);
+
         this.#entity_id_by_network = new_entities;
         this.#generation_by_network = new_generations;
+        this.#free_position_by_network = new_free_positions;
         this.#capacity = new_capacity;
     }
 }

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#483@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#485@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#483@#clear_field"(fluid: FluidComponent): void;
+    static "__#485@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#483@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#485@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#483@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#485@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/generation/markers/GridActionRuleSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridActionRuleSet.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridActionRuleSet.js"],"names":[],"mappings":"AA2BA;IA0BI;;;;;;;;OAQG;IACH;QAN4C,KAAK,EAAtC,uBAAuB;QACW,MAAM,GAAxC,uBAAuB;QACJ,OAAO,GAA1B,MAAM,EAAE;QACU,kBAAkB,GAApC,OAAO;QACL,iBAAiB,CAkB7B;IAjDD;;;OAGG;IACH,UAFU,uBAAuB,CAEnB;IAEd;;;OAGG;IACH,QAFU,uBAAuB,GAAC,MAAM,CAEI;IAE5C;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,aAFU,OAAO,CAEE;IA6BnB;;;OAGG;IACH,uCAEC;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,eACN,MAAM,QAiIhB;CACJ;wCArNuC,8BAA8B"}
+{"version":3,"file":"GridActionRuleSet.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridActionRuleSet.js"],"names":[],"mappings":"AA4BA;IA0BI;;;;;;;;OAQG;IACH;QAN4C,KAAK,EAAtC,uBAAuB;QACW,MAAM,GAAxC,uBAAuB;QACJ,OAAO,GAA1B,MAAM,EAAE;QACU,kBAAkB,GAApC,OAAO;QACL,iBAAiB,CAkB7B;IAjDD;;;OAGG;IACH,UAFU,uBAAuB,CAEnB;IAEd;;;OAGG;IACH,QAFU,uBAAuB,GAAC,MAAM,CAEI;IAE5C;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,aAFU,OAAO,CAEE;IA6BnB;;;OAGG;IACH,uCAEC;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,eACN,MAAM,QAyIhB;CACJ;wCA7NuC,8BAA8B"}

package/src/generation/markers/GridActionRuleSet.js

@@ -3,6 +3,7 @@ import { ArrayIteratorRandom } from "../../core/collection/array/iterator/ArrayI
 import { ArrayIteratorSequential } from "../../core/collection/array/iterator/ArrayIteratorSequential.js";
 import { v2_rotate } from "../../core/geom/vec2/v2_rotate.js";
 import { PI_HALF } from "../../core/math/PI_HALF.js";
+import { randomIntegerBetween } from "../../core/math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 import TaskGroup from "../../core/process/task/TaskGroup.js";
 import { countTask } from "../../core/process/task/util/countTask.js";
@@ -146,7 +147,6 @@ export class GridActionRuleSet {
 
         const tMain = randomCountTask(seed, 0, sampleCount, index => {
 
-
             const sample_y = (index / sampleCountX) | 0;
             const sample_x = index % sampleCountX;
 
@@ -166,11 +166,19 @@ export class GridActionRuleSet {
 
                 const matcher = element.pattern;
 
+                let ROTATION_COUNT = 1;
+                let INITIAL_ROTATION = 0;
+
+                if (element.allowRotation) {
+                    ROTATION_COUNT = 4;
+                    // to avoid biasing rotation 0, we pick a random initial rotation; the sequence is always the same though
+                    INITIAL_ROTATION = randomIntegerBetween(random, 0, 3);
+                }
+
                 sampling_loop: for (let sampleIndex = 0; sampleIndex < patternSize;) {
                     const sampleOffsetX = pattern[sampleIndex++];
                     const sampleOffsetY = pattern[sampleIndex++];
 
-                    const ROTATION_COUNT = element.allowRotation ? 4 : 1;
 
                     // a single roll per placement attempt: whether the rule fires is decided once,
                     // the rotation scan only decides the orientation. Rolling per rotation would
@@ -178,8 +186,9 @@ export class GridActionRuleSet {
                     const roll = random();
 
                     for (let j = 0; j < ROTATION_COUNT; j++) {
+                        const rotation_index = (j + INITIAL_ROTATION) % 4;
 
-                        const rotation = j * PI_HALF;
+                        const rotation = rotation_index * PI_HALF;
 
                         v2_rotate(scratch_offset, 0, sampleOffsetX, sampleOffsetY, rotation);
 

package/src/shade/renderer/GraphicsContext.d.ts

@@ -17,6 +17,13 @@ export class GraphicsContext {
      * @returns {GPUResidentMaterialContext}
      */
     get materials_resident(): GPUResidentMaterialContext;
+    /**
+     * The G-buffer pass as {@link MaterialDispatch.Compute} runs it, over {@link materials}. Made on
+     * first use: a renderer on the default dispatch never makes it.
+     *
+     * @returns {GPUMaterialComputeDispatch}
+     */
+    get materials_compute(): GPUMaterialComputeDispatch;
     /**
      *
      * @return {GPUCollectionLimits}
@@ -156,6 +163,7 @@ import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUMaterialManager } from "./material/GPUMaterialManager.js";
 import { GPUSamplerManager } from "./GPUSamplerManager.js";
 import { GPUResidentMaterialContext } from "./material/resident/GPUResidentMaterialContext.js";
+import { GPUMaterialComputeDispatch } from "./material/dispatch/GPUMaterialComputeDispatch.js";
 import { GPUCollectionLimits } from "./rasterize/expand/GPUCollectionLimits.js";
 import { PipelineLayoutManager } from "../device/pipeline/PipelineLayoutManager.js";
 import { RenderPipelineManager } from "../device/pipeline/RenderPipelineManager.js";

package/src/shade/renderer/GraphicsContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAmCA;IAqKI,yBAiCC;IArMD;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAOV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAQC;IAED;;;OAGG;IACH,wBAEC;IAqCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QA2B9D;IAED;;;;;;;;;OASG;IACH,8DAJW,sBAAsB,SACtB,MAAM,aACN,oBAAoB,QA0C9B;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAgBC;IAED,4BAEC;IAED,eAoDC;IAED;;;;;;OAMG;IACH,gBAsBC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA9ZY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAjBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAEf,mDAAmD;oCAH1D,2CAA2C;sCAbzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAgBhD,6BAA6B;sCACtB,4CAA4C;iCAfjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;yCACxC,sCAAsC;2CAFpC,wCAAwC;oCAS/C,kCAAkC;iCAVtB,8BAA8B"}
+{"version":3,"file":"GraphicsContext.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/GraphicsContext.js"],"names":[],"mappings":"AAoCA;IA6LI,yBAiCC;IA7ND;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAYV;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;;OAGG;IACH,qDAOC;IAED;;;;;OAKG;IACH,oDAWC;IAOD;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,mBAFU,sBAAsB,CAEd;IAGlB;;OAEG;IACH,gBAFU,oBAAoB,CAEf;IAEf;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;;;OAIG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;OAEG;IACH,aAFU,gBAAgB,CAEd;IAQZ;;;OAGG;IACH,uBAFU,kBAAkB,CAEN;IAEtB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,0BAFU,yBAAyB,CAEV;IAEzB;;;;OAIG;IACH,yBAFU,wBAAwB,CAEV;IAExB;;;;OAIG;IACH,2BAFU,0BAA0B,CAEV;IAE1B;;;OAGG;IACH,oBAFU,mBAAmB,CAEV;IAUnB;;;OAGG;IACH,8BAEC;IAED,uBAQC;IAED;;;OAGG;IACH,wBAEC;IAqCD;;;;;;;;OAQG;IACH,6DANW,sBAAsB,aACtB,oBAAoB,EAAE,cACtB;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,QA2B9D;IAED;;;;;;;;;OASG;IACH,8DAJW,sBAAsB,SACtB,MAAM,aACN,oBAAoB,QA0C9B;IAED;;;;OAIG;IACH,gCAHW,gBAAgB,GACd,gBAAgB,CAI5B;IAED;;OAEG;IACH,+BAgBC;IAED,4BAEC;IAED,eAoDC;IAED;;;;;;OAMG;IACH,gBA0BC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;+BA1bY,OAAO,0CAA0C,EAAE,gBAAgB;qCACnE,OAAO,kDAAkD,EAAE,sBAAsB;2BAKjF,OAAO,mCAAmC,EAAE,YAAY;mCAlBlC,kCAAkC;mCAGlC,kCAAkC;kCADnC,wBAAwB;2CAGf,mDAAmD;2CADnD,mDAAmD;oCAH1D,2CAA2C;sCAbzC,6CAA6C;sCAC7C,6CAA6C;uCAF5C,8CAA8C;qCAIhD,0CAA0C;+BAiBhD,6BAA6B;sCACtB,4CAA4C;iCAhBjD,+BAA+B;mCAC7B,gCAAgC;yCAC1B,sCAAsC;0CAGrC,uCAAuC;yCACxC,sCAAsC;2CAFpC,wCAAwC;oCAU/C,kCAAkC;iCAXtB,8BAA8B"}

package/src/shade/renderer/GraphicsContext.js

@@ -16,6 +16,7 @@ import { GPUGeometryManager } from "./geometry/GPUGeometryManager.js";
 import { GPUCollectionLimits } from "./rasterize/expand/GPUCollectionLimits.js";
 import { GPUSamplerManager } from "./GPUSamplerManager.js";
 import { GPUMaterialManager } from "./material/GPUMaterialManager.js";
+import { GPUMaterialComputeDispatch } from "./material/dispatch/GPUMaterialComputeDispatch.js";
 import { GPUResidentMaterialContext } from "./material/resident/GPUResidentMaterialContext.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "./STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { GPUTextureAllocator } from "./texture/GPUTextureAllocator.js";
@@ -49,6 +50,11 @@ export class GraphicsContext {
      */
     #materials_resident
 
+    /**
+     * @type {GPUMaterialComputeDispatch|undefined}
+     */
+    #materials_compute = undefined;
+
     /**
      * @type {GPUSamplerManager}
      */
@@ -67,6 +73,25 @@ export class GraphicsContext {
         return this.#materials_resident;
     }
 
+    /**
+     * The G-buffer pass as {@link MaterialDispatch.Compute} runs it, over {@link materials}. Made on
+     * first use: a renderer on the default dispatch never makes it.
+     *
+     * @returns {GPUMaterialComputeDispatch}
+     */
+    get materials_compute() {
+        if (this.#materials_compute === undefined) {
+            this.#materials_compute = new GPUMaterialComputeDispatch({
+                device: this.#device,
+                materials: this.materials,
+                compute_pipelines: this.compute_pipelines,
+                bindings: this.bind_groups,
+            });
+        }
+
+        return this.#materials_compute;
+    }
+
     /**
      * @type {GPUCollectionLimits}
      */
@@ -421,6 +446,10 @@ export class GraphicsContext {
 
         this.materials.destroy();
 
+        if (this.#materials_compute !== undefined) {
+            this.#materials_compute.destroy();
+        }
+
         if (this.#materials_resident !== undefined) {
             this.#materials_resident.destroy();
         }

package/src/shade/renderer/Renderer.d.ts

@@ -29,6 +29,15 @@ export class Renderer {
      * @type {ShadeIndirectLightingMode}
      */
     indirect_lighting_mode: ShadeIndirectLightingMode;
+    /**
+     * How the G-buffer pass runs each material over its pixels of the visibility buffer — see
+     * {@link MaterialDispatch}. Read when a frame is recorded, so it can change between any two.
+     * Both run the same laydown. {@link MaterialDispatch.Compute} is experimental and slower on
+     * high-end GPUs; leave this on {@link MaterialDispatch.Quad} unless measuring it.
+     *
+     * @type {MaterialDispatch}
+     */
+    material_dispatch: MaterialDispatch;
     /**
      * Settings of {@link ShadeIndirectLightingMode.ProbeClipmap}, read every frame it runs. A change to
      * one of its structural fields builds the mode's clipmaps again; see {@link ProbeClipmapSettings}.
@@ -567,6 +576,7 @@ export type GPUSceneContext = import("./scene/GPUSceneContext.js").GPUSceneConte
 export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -101,6 +101,7 @@ import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
@@ -228,6 +229,16 @@ export class Renderer {
      */
     indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
 
+    /**
+     * How the G-buffer pass runs each material over its pixels of the visibility buffer — see
+     * {@link MaterialDispatch}. Read when a frame is recorded, so it can change between any two.
+     * Both run the same laydown. {@link MaterialDispatch.Compute} is experimental and slower on
+     * high-end GPUs; leave this on {@link MaterialDispatch.Quad} unless measuring it.
+     *
+     * @type {MaterialDispatch}
+     */
+    material_dispatch = MaterialDispatch.Quad;
+
     /**
      * Settings of {@link ShadeIndirectLightingMode.ProbeClipmap}, read every frame it runs. A change to
      * one of its structural fields builds the mode's clipmaps again; see {@link ProbeClipmapSettings}.
@@ -1855,7 +1866,8 @@ export class Renderer {
                 size: resolution_internal,
                 format: G_BUFFER_COLOR_TARGETS[1].format,
                 mipLevelCount: 1,
-                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+                // storage too, for the compute material dispatch, which can be chosen on any frame
+                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
             }));
         }
 
@@ -1930,6 +1942,10 @@ export class Renderer {
         const color_formats = [deferred_shader.pipeline.fragment.targets[0].format];
 
         graphics.materials.enquirePipelines(enquiry);
+
+        if (this.material_dispatch === MaterialDispatch.Compute) {
+            graphics.materials_compute.enquirePipelines(enquiry);
+        }
         this.#scenes.enquirePipelines(enquiry);
 
         enquire_rasterize_scene_pipelines(enquiry, viz_rasterization_opaque_pass_descriptor, CullPolicy.Standard);
@@ -2784,7 +2800,11 @@ export class Renderer {
         }
 
         // run materials
-        const mat_g = graphics.materials.graph_viz_render({
+        const material_pass = this.material_dispatch === MaterialDispatch.Compute
+            ? graphics.materials_compute
+            : graphics.materials;
+
+        const mat_g = material_pass.graph_viz_render({
             graph,
             view: view_ctx,
             texture_viz_mesh: gr_viz_buffer_mesh,

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#281@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#283@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#281@#execute_fill"(record: object, _resources: any, context: {
+    static "__#283@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#281@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#283@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#283@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#285@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#284@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#286@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#284@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#286@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#284@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#284@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#284@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#284@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#286@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#286@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#286@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#286@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#280@#execute"(data: {
+    static "__#282@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#285@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#287@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -33,7 +33,7 @@ export class GPUProbeClipmapGI {
      * @param {ProbeClipmapSettings} settings
      * @returns {boolean} whether it is what the settings' world cache describes, in their frustum's windows
      */
-    static "__#206@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
+    static "__#208@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/light/GPULightCollection.d.ts

@@ -72,13 +72,15 @@ export class GPULightCollection {
      */
     update(ctx: GraphicsContext): void;
     /**
-     * Hold a `transforms` row for every light's entity, and let go of the rows of lights that left.
+     * Hold a `transforms` row for every light's entity.
      *
      * Called by the scene context before it flushes its rows, so a light that arrived this frame is
      * written this frame; runs only when the source's version moved, and a moved light is one of
      * the things that moves it, so every held row is marked as well — a mark on a row the GPU
      * composes writes nothing.
      *
+     * The row of a light that leaves goes as it leaves ({@link #removed}), not here.
+     *
      * @param {import("../scene/rows/GPUSceneRows.js").GPUSceneRows} rows
      */
     sync_rows(rows: import("../scene/rows/GPUSceneRows.js").GPUSceneRows): void;

package/src/shade/renderer/light/GPULightCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AAoDA;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAOzB;IA6KD;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA2CzB;IAnND;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IA6DD;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,yCAEC;IAGD,4BAMC;IAoMD;;;OAGG;IACH,YAFW,eAAe,QAoCzB;IAED;;;;;;;;;OASG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QAkC9D;IAED;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCA6BhC;IAwED,gBAUC;;CACJ;8BA1lBY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BA7B/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}
+{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AAoDA;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAOzB;IAmLD;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA6CzB;IA3ND;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAmED;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,yCAEC;IAGD,4BAMC;IAsMD;;;OAGG;IACH,YAFW,eAAe,QAoCzB;IAED;;;;;;;;;;;OAWG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QA2B9D;IAqBD;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCA6BhC;IAwED,gBAaC;;CACJ;8BAnnBY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BA7B/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}

package/src/shade/renderer/light/GPULightCollection.js

@@ -150,6 +150,12 @@ export class GPULightCollection {
      */
     #held = new Map();
 
+    /**
+     * The rows {@link #held} is held in: the scene context's, from the first {@link sync_rows}.
+     * @type {import("../scene/rows/GPUSceneRows.js").GPUSceneRows|null}
+     */
+    #rows = null;
+
     /**
      * The source version {@link sync_rows} last reconciled the held rows against.
      * @type {number}
@@ -254,6 +260,8 @@ export class GPULightCollection {
         this.#device = device;
         this.#source = scene.lights;
 
+        this.#source.onRemoved.add(this.#removed, this);
+
         this.#environment = new GPUTextureContext(this.#device);
         this.#environment.descriptor.label = "environment map";
         this.#environment.descriptor.format = "rgba16float";
@@ -471,13 +479,15 @@ export class GPULightCollection {
     }
 
     /**
-     * Hold a `transforms` row for every light's entity, and let go of the rows of lights that left.
+     * Hold a `transforms` row for every light's entity.
      *
      * Called by the scene context before it flushes its rows, so a light that arrived this frame is
      * written this frame; runs only when the source's version moved, and a moved light is one of
      * the things that moves it, so every held row is marked as well — a mark on a row the GPU
      * composes writes nothing.
      *
+     * The row of a light that leaves goes as it leaves ({@link #removed}), not here.
+     *
      * @param {import("../scene/rows/GPUSceneRows.js").GPUSceneRows} rows
      */
     sync_rows(rows) {
@@ -487,6 +497,8 @@ export class GPULightCollection {
             return;
         }
 
+        this.#rows = rows;
+
         const held = this.#held;
         const lights = source.elements;
 
@@ -502,16 +514,26 @@ export class GPULightCollection {
             }
         }
 
-        if (held.size !== lights.length) {
-            for (const [light, entity] of held) {
-                if (!source.has(light)) {
-                    rows.release(entity);
-                    held.delete(light);
-                }
-            }
+        this.#rows_version = source.version;
+    }
+
+    /**
+     * A light left the scene's collection: its row goes now, while its entity is still the one
+     * that id names.
+     *
+     * @param {import("./model/Light.js").Light} light
+     */
+    #removed(light) {
+        const entity = this.#held.get(light);
+
+        if (entity === undefined) {
+            // not taken yet — it arrived and left between two builds
+            return;
         }
 
-        this.#rows_version = source.version;
+        this.#held.delete(light);
+
+        this.#rows.release(entity);
     }
 
     /**
@@ -620,8 +642,11 @@ export class GPULightCollection {
     }
 
     destroy() {
+        this.#source.onRemoved.remove(this.#removed, this);
+
         // the rows go with the context that held them
         this.#held.clear();
+        this.#rows = null;
         this.#rows_version = -1;
 
         this.#shadow_context.destroy();

package/src/shade/renderer/light/LightCollection.d.ts

@@ -7,9 +7,11 @@
  *
  * A light is placed by naming the entity it stands at: the entity's `transforms` row is where the
  * GPU reads the light's pose from, and the scene's GPU context holds that row on the collection's
- * behalf for as long as the light is here. The collection itself is CPU data — the renderer's
- * mirror of it (`GPULightCollection`) is rebuilt whenever {@link version} moves, which adding and
- * removing do on their own and a change in place does through {@link needsUpdate}.
+ * behalf for as long as the light is here: taken by the next build, let go as the light leaves
+ * ({@link onRemoved}), since the entity may go next and its id be handed on. The collection itself
+ * is CPU data — the renderer's mirror of it (`GPULightCollection`) is rebuilt whenever
+ * {@link version} moves, which adding and removing do on their own and a change in place does
+ * through {@link needsUpdate}.
  */
 export class LightCollection {
     /**
@@ -49,6 +51,14 @@ export class LightCollection {
      * @param {number} entity
      */
     add(light: Light, entity: number): void;
+    /**
+     * A light has left, and the entity it stood at with it — sent from {@link remove}, before the
+     * caller can remove that entity and its dataset hand the id to another. Whatever holds the
+     * entity's row for the light lets go here.
+     *
+     * @type {Signal<Light, number>} the light, its entity
+     */
+    onRemoved: any;
     /**
      * Remove a light. Returns true if it was found and dropped.
      *