@woosh/meep-engine 3.60.7 → 3.60.9

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

@@ -1 +1 @@
-{"version":3,"file":"LightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/LightCollection.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;;;GAQG;AACH;IAeI;;;OAGG;IACH,mDAEC;IAgBD;;;OAGG;IACH,sEAMC;IAlBD;;;OAGG;IACH,qEAEC;IAiBD;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,4BAIC;IAED;;;;;;;;;;OAUG;IACH,WAHW,KAAK,UACL,MAAM,QAYhB;IAED;;;;;OAKG;IACH,cAHW,KAAK,GACH,OAAO,CAYnB;IAED;;;OAGG;IACH,WAHW,KAAK,GACH,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,KAAK,GACH,MAAM,GAAC,SAAS,CAI5B;;CACJ;2BA7IY,OAAO,4BAA4B,EAAE,YAAY;oBACjD,OAAO,kBAAkB,EAAE,KAAK"}
+{"version":3,"file":"LightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/LightCollection.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH;IAeI;;;OAGG;IACH,mDAEC;IAgBD;;;OAGG;IACH,sEAMC;IAlBD;;;OAGG;IACH,qEAEC;IAiBD;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,4BAIC;IAED;;;;;;;;;;OAUG;IACH,WAHW,KAAK,UACL,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,eAAyB;IAEzB;;;;;OAKG;IACH,cAHW,KAAK,GACH,OAAO,CAgBnB;IAED;;;OAGG;IACH,WAHW,KAAK,GACH,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,KAAK,GACH,MAAM,GAAC,SAAS,CAI5B;;CACJ;2BA5JY,OAAO,4BAA4B,EAAE,YAAY;oBACjD,OAAO,kBAAkB,EAAE,KAAK"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { array_remove_first } from "../../../core/collection/array/array_remove_first.js";
+import Signal from "../../../core/events/signal/Signal.js";
 
 /**
  * @typedef {import("../texture/ShadeTexture.js").ShadeTexture} ShadeTexture
@@ -11,9 +12,11 @@ import { array_remove_first } from "../../../core/collection/array/array_remove_
  *
  * 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 {
 
@@ -108,6 +111,15 @@ export class LightCollection {
         this.#version++;
     }
 
+    /**
+     * 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 = new Signal();
+
     /**
      * Remove a light. Returns true if it was found and dropped.
      *
@@ -118,9 +130,13 @@ export class LightCollection {
         const removed = array_remove_first(this.#elements, light);
 
         if (removed) {
+            const entity = this.#entities.get(light);
+
             this.#entities.delete(light);
 
             this.#version++;
+
+            this.onRemoved.send2(light, entity);
         }
 
         return removed;

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#304@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#306@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/GPUMaterialManager.d.ts

@@ -118,6 +118,27 @@ export class GPUMaterialManager {
      * @returns {ShadeMaterial[]}
      */
     forward_drawable(drawn: ShadeMaterial[]): ShadeMaterial[];
+    /**
+     * The contexts the G-buffer pass draws for a scene's drawn materials: every one that is not
+     * transparent and has a context, grouped by template, in the order {@link graph_viz_render} draws
+     * them. The array is kept and rebuilt in place — {@link gbuffer_contexts_version} says when.
+     *
+     * @param {ShadeMaterial[]} drawn a scene's {@link GPUSceneContext#drawn_materials}
+     * @returns {GPUMaterialContext[]}
+     */
+    gbuffer_contexts(drawn: ShadeMaterial[]): GPUMaterialContext[];
+    /**
+     * Moves whenever {@link gbuffer_contexts} may answer differently for the same drawn set.
+     *
+     * @returns {number}
+     */
+    get gbuffer_contexts_version(): number;
+    /**
+     * What every template's hooks are handed, for a pass that calls them itself.
+     *
+     * @returns {GPUMaterialServices}
+     */
+    get services(): GPUMaterialServices;
     /**
      *
      * @param {ShadeGPUCommandContext} ctx
@@ -138,4 +159,5 @@ export type ShadeMaterial = import("./ShadeMaterial.js").ShadeMaterial;
 export type ShadeMaterialTemplate = import("./template/ShadeMaterialTemplate.js").ShadeMaterialTemplate;
 import { GPUMaterialContext } from "./GPUMaterialContext.js";
 import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
+import { GPUMaterialServices } from "./template/GPUMaterialServices.js";
 //# sourceMappingURL=GPUMaterialManager.d.ts.map

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4LnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAl4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4LnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;;OAOG;IACH,wBAHW,aAAa,EAAE,GACb,kBAAkB,EAAE,CAIhC;IAED;;;;OAIG;IACH,uCAEC;IAED;;;;OAIG;IACH,oCAEC;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAh6BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C;oCAoBxB,mCAAmC"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -824,6 +824,36 @@ export class GPUMaterialManager {
         return this.#lists_of(drawn).forward;
     }
 
+    /**
+     * The contexts the G-buffer pass draws for a scene's drawn materials: every one that is not
+     * transparent and has a context, grouped by template, in the order {@link graph_viz_render} draws
+     * them. The array is kept and rebuilt in place — {@link gbuffer_contexts_version} says when.
+     *
+     * @param {ShadeMaterial[]} drawn a scene's {@link GPUSceneContext#drawn_materials}
+     * @returns {GPUMaterialContext[]}
+     */
+    gbuffer_contexts(drawn) {
+        return this.#gbuffer_contexts(drawn);
+    }
+
+    /**
+     * Moves whenever {@link gbuffer_contexts} may answer differently for the same drawn set.
+     *
+     * @returns {number}
+     */
+    get gbuffer_contexts_version() {
+        return this.#list_version;
+    }
+
+    /**
+     * What every template's hooks are handed, for a pass that calls them itself.
+     *
+     * @returns {GPUMaterialServices}
+     */
+    get services() {
+        return this.#services;
+    }
+
     /**
      * @param {ShadeMaterial[]} drawn
      * @returns {GPUMaterialContext[]}

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The G-buffer pass as {@link MaterialDispatch.Compute} runs it — **experimental, off by default, not
+ * the main path**; why, with the measurements, is in `COMPUTE_MATERIAL_DISPATCH.md` beside this file.
+ * Everything that path holds is here, kept apart from {@link GPUMaterialManager}, whose fragment
+ * dispatch is the default and knows nothing of this one.
+ *
+ * What it reads of the manager is public and read-only: the contexts the G-buffer pass draws, the
+ * version that says when those change, the services templates are handed, and every context there
+ * is, to offer their templates' pipelines. A context's fragment bind group is read only as a token
+ * that says when the template rebuilt it. What it makes is its
+ * own: each template's compute pipeline, each material's group 0 for it (by the template's own
+ * {@link ShadeMaterialTemplate#create_bind_group}, over the compute layout), the material id → slot
+ * tables, and the per-material dispatch records.
+ */
+export class GPUMaterialComputeDispatch {
+    /**
+     * @param {Object} options
+     * @param {GPUDevice} options.device
+     * @param {GPUMaterialManager} options.materials whose materials it shades
+     * @param {ComputePipelineManager} options.compute_pipelines
+     * @param {BindGroupManager} options.bindings
+     */
+    constructor({ device, materials, compute_pipelines, bindings }: {
+        device: GPUDevice;
+        materials: GPUMaterialManager;
+        compute_pipelines: ComputePipelineManager;
+        bindings: BindGroupManager;
+    });
+    /**
+     * Lay the G-buffer of `view` down — what {@link GPUMaterialManager#graph_viz_render} does, by
+     * {@link graph_material_dispatch_compute}, and with the same arguments and result.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view
+     * @param {number} options.texture_viz_mesh
+     * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution, with `STORAGE_BINDING`
+     * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
+     */
+    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
+        graph: FrameGraph;
+        view: GPUViewContext;
+        texture_viz_mesh: number;
+        texture_viz_triangle: number;
+        texture_normal: number;
+    }): {
+        g_pbr: number;
+        g_normal: number;
+        g_albedo: number;
+        g_emissive: number;
+    };
+    /**
+     * Offer the pipelines this path dispatches — see {@link PipelineEnquiry}: the classification's,
+     * and the compute G-buffer pipeline of the standard template and of every template a material
+     * has brought.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry: PipelineEnquiry): void;
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type ComputePipelineDescriptor = import("../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor;
+export type ComputePipelineManager = import("../../../device/pipeline/ComputePipelineManager.js").ComputePipelineManager;
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+export type BindGroupManager = import("../../binding/BindGroupManager.js").BindGroupManager;
+export type GPUViewContext = import("../../view/GPUViewContext.js").GPUViewContext;
+export type GPUMaterialContext = import("../GPUMaterialContext.js").GPUMaterialContext;
+export type GPUMaterialManager = import("../GPUMaterialManager.js").GPUMaterialManager;
+export type ShadeMaterial = import("../ShadeMaterial.js").ShadeMaterial;
+export type ShadeMaterialTemplate = import("../template/ShadeMaterialTemplate.js").ShadeMaterialTemplate;
+//# sourceMappingURL=GPUMaterialComputeDispatch.d.ts.map

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUMaterialComputeDispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;GAaG;AACH;IA8DI;;;;;;OAMG;IACH;QAL8B,MAAM;QACG,SAAS,EAArC,kBAAkB;QACc,iBAAiB,EAAjD,sBAAsB;QACI,QAAQ,EAAlC,gBAAgB;OAa1B;IAED;;;;;;;;;;;;OAYG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA0BnF;IAED;;;;;;OAMG;IACH,0BAFW,eAAe,QAazB;IAED,gBAOC;;CAqHJ;yBAlUY,OAAO,8DAA8D,EAAE,UAAU;wCACjF,OAAO,mEAAmE,EAAE,yBAAyB;qCACrG,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,6CAA6C,EAAE,eAAe;+BACrE,OAAO,mCAAmC,EAAE,gBAAgB;6BAC5D,OAAO,8BAA8B,EAAE,cAAc;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;iCACrD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,sCAAsC,EAAE,qBAAqB"}

package/src/shade/renderer/material/dispatch/GPUMaterialComputeDispatch.js

@@ -0,0 +1,338 @@
+import { assert } from "../../../../core/assert.js";
+import {
+    cpu_hash_table_create,
+    cpu_hash_table_word_count
+} from "../../gpu_primitive/hash_table/cpu_build_hash_table.js";
+import { enquire_prefix_scan_csdldf_pipelines } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { STANDARD_MATERIAL_TEMPLATE } from "../standard/STANDARD_MATERIAL_TEMPLATE.js";
+import { build_gbuffer_compute_pipeline_descriptor } from "./gbuffer_compute.js";
+import { graph_material_dispatch_compute } from "./graph_material_dispatch_compute.js";
+import { MaterialDispatchRecords } from "./MaterialDispatchRecords.js";
+import { shader_material_dispatch_commands } from "./shader_material_dispatch_commands.js";
+import { shader_material_pixel_count } from "./shader_material_pixel_count.js";
+import { shader_material_pixel_scatter } from "./shader_material_pixel_scatter.js";
+
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js").ComputePipelineDescriptor} ComputePipelineDescriptor
+ * @typedef {import("../../../device/pipeline/ComputePipelineManager.js").ComputePipelineManager} ComputePipelineManager
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ * @typedef {import("../../binding/BindGroupManager.js").BindGroupManager} BindGroupManager
+ * @typedef {import("../../view/GPUViewContext.js").GPUViewContext} GPUViewContext
+ * @typedef {import("../GPUMaterialContext.js").GPUMaterialContext} GPUMaterialContext
+ * @typedef {import("../GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
+ * @typedef {import("../ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ * @typedef {import("../template/ShadeMaterialTemplate.js").ShadeMaterialTemplate} ShadeMaterialTemplate
+ */
+
+/**
+ * A material's group 0 for its template's compute pipeline, and the fragment bind group it was made
+ * beside — when the template rebuilds that one, this one is made again.
+ */
+class ComputeMaterialGroup {
+    /**
+     * @type {GPUBindGroup}
+     */
+    source;
+
+    /**
+     * @type {GPUBindGroup}
+     */
+    group;
+}
+
+/**
+ * The material id → slot table of one drawn set, and the list version it was built at.
+ */
+class MaterialSlotTable {
+    /**
+     * @type {Uint32Array}
+     */
+    table = new Uint32Array(0);
+
+    /**
+     * @type {number}
+     */
+    version = -1;
+}
+
+/**
+ * The G-buffer pass as {@link MaterialDispatch.Compute} runs it — **experimental, off by default, not
+ * the main path**; why, with the measurements, is in `COMPUTE_MATERIAL_DISPATCH.md` beside this file.
+ * Everything that path holds is here, kept apart from {@link GPUMaterialManager}, whose fragment
+ * dispatch is the default and knows nothing of this one.
+ *
+ * What it reads of the manager is public and read-only: the contexts the G-buffer pass draws, the
+ * version that says when those change, the services templates are handed, and every context there
+ * is, to offer their templates' pipelines. A context's fragment bind group is read only as a token
+ * that says when the template rebuilt it. What it makes is its
+ * own: each template's compute pipeline, each material's group 0 for it (by the template's own
+ * {@link ShadeMaterialTemplate#create_bind_group}, over the compute layout), the material id → slot
+ * tables, and the per-material dispatch records.
+ */
+export class GPUMaterialComputeDispatch {
+    /**
+     * @type {GPUMaterialManager}
+     */
+    #materials;
+
+    /**
+     * @type {ComputePipelineManager}
+     */
+    #compute_pipelines;
+
+    /**
+     * @type {BindGroupManager}
+     */
+    #bindings;
+
+    /**
+     * @type {MaterialDispatchRecords}
+     */
+    #records;
+
+    /**
+     * @type {Map<ShadeMaterialTemplate, ComputePipelineDescriptor>}
+     */
+    #pipeline_descriptors = new Map();
+
+    /**
+     * @type {Map<ShadeMaterialTemplate, GPUComputePipeline>}
+     */
+    #pipelines = new Map();
+
+    /**
+     * Weak, so a released context takes its group with it.
+     *
+     * @type {WeakMap<GPUMaterialContext, ComputeMaterialGroup>}
+     */
+    #groups = new WeakMap();
+
+    /**
+     * Per drawn set, which the scene replaces when it changes. Weak, as the manager's lists are.
+     *
+     * @type {WeakMap<ShadeMaterial[], MaterialSlotTable>}
+     */
+    #slot_tables = new WeakMap();
+
+    /**
+     * The table being built, kept to build the next one in.
+     *
+     * @type {number[]}
+     */
+    #slot_ids = [];
+
+    /**
+     * @type {function(GPUMaterialContext):GPUComputePipeline}
+     */
+    #pipeline_of = material_ctx => this.#pipeline(material_ctx.template);
+
+    /**
+     * @type {function(GPUMaterialContext):GPUBindGroup}
+     */
+    #group_of = material_ctx => this.#group(material_ctx);
+
+    /**
+     * @param {Object} options
+     * @param {GPUDevice} options.device
+     * @param {GPUMaterialManager} options.materials whose materials it shades
+     * @param {ComputePipelineManager} options.compute_pipelines
+     * @param {BindGroupManager} options.bindings
+     */
+    constructor({ device, materials, compute_pipelines, bindings }) {
+        assert.defined(device, 'device');
+        assert.defined(materials, 'materials');
+        assert.defined(compute_pipelines, 'compute_pipelines');
+        assert.defined(bindings, 'bindings');
+
+        this.#materials = materials;
+        this.#compute_pipelines = compute_pipelines;
+        this.#bindings = bindings;
+
+        this.#records = new MaterialDispatchRecords(device, bindings);
+    }
+
+    /**
+     * Lay the G-buffer of `view` down — what {@link GPUMaterialManager#graph_viz_render} does, by
+     * {@link graph_material_dispatch_compute}, and with the same arguments and result.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view
+     * @param {number} options.texture_viz_mesh
+     * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution, with `STORAGE_BINDING`
+     * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}}
+     */
+    graph_viz_render({
+                         graph,
+                         view,
+                         texture_viz_mesh,
+                         texture_viz_triangle,
+                         texture_normal,
+                     }) {
+        const drawn = view.scene.drawn_materials;
+
+        const contexts = this.#materials.gbuffer_contexts(drawn);
+
+        return graph_material_dispatch_compute({
+            graph,
+            view,
+            contexts,
+            material_slots: this.#slot_table(drawn, contexts),
+            records: this.#records,
+            bindings: this.#bindings,
+            pipeline_of: this.#pipeline_of,
+            group_of: this.#group_of,
+            texture_viz_mesh,
+            texture_viz_triangle,
+            texture_normal,
+        });
+    }
+
+    /**
+     * Offer the pipelines this path dispatches — see {@link PipelineEnquiry}: the classification's,
+     * and the compute G-buffer pipeline of the standard template and of every template a material
+     * has brought.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry) {
+        enquiry.compute.push(shader_material_pixel_count.pipeline);
+        enquiry.compute.push(shader_material_pixel_scatter.pipeline);
+        enquiry.compute.push(shader_material_dispatch_commands.pipeline);
+        enquire_prefix_scan_csdldf_pipelines(enquiry);
+
+        enquiry.compute.push(this.#pipeline_descriptor(STANDARD_MATERIAL_TEMPLATE));
+
+        for (const material_ctx of this.#materials.contexts.values()) {
+            enquiry.compute.push(this.#pipeline_descriptor(material_ctx.template));
+        }
+    }
+
+    destroy() {
+        this.#records.destroy();
+
+        this.#pipelines.clear();
+        this.#pipeline_descriptors.clear();
+        this.#groups = new WeakMap();
+        this.#slot_tables = new WeakMap();
+    }
+
+    /**
+     * @param {ShadeMaterialTemplate} template
+     * @returns {ComputePipelineDescriptor}
+     */
+    #pipeline_descriptor(template) {
+        let descriptor = this.#pipeline_descriptors.get(template);
+
+        if (descriptor === undefined) {
+            descriptor = build_gbuffer_compute_pipeline_descriptor({
+                label: `${template.name} material / Viz-Buffer to G-Buffer compute laydown`,
+                material_group: template.resources,
+                surface: template.gbuffer_surface(this.#materials.services),
+            });
+
+            this.#pipeline_descriptors.set(template, descriptor);
+        }
+
+        return descriptor;
+    }
+
+    /**
+     * @param {ShadeMaterialTemplate} template
+     * @returns {GPUComputePipeline}
+     */
+    #pipeline(template) {
+        let pipeline = this.#pipelines.get(template);
+
+        if (pipeline === undefined) {
+            pipeline = this.#compute_pipelines.obtain(this.#pipeline_descriptor(template));
+
+            this.#pipelines.set(template, pipeline);
+        }
+
+        return pipeline;
+    }
+
+    /**
+     * The material's group 0 for its template's compute pipeline, made by the template from the same
+     * resources as its fragment bind group, and made again whenever the template has rebuilt that one.
+     *
+     * @param {GPUMaterialContext} material_ctx
+     * @returns {GPUBindGroup}
+     */
+    #group(material_ctx) {
+        const source = material_ctx.material_binding;
+
+        let entry = this.#groups.get(material_ctx);
+
+        if (entry === undefined) {
+            entry = new ComputeMaterialGroup();
+
+            this.#groups.set(material_ctx, entry);
+        }
+
+        if (entry.source !== source) {
+            const template = material_ctx.template;
+
+            entry.group = template.create_bind_group(
+                material_ctx,
+                this.#pipeline(template).getBindGroupLayout(0),
+                this.#materials.services
+            );
+
+            entry.source = source;
+        }
+
+        return entry.group;
+    }
+
+    /**
+     * Each context's place among `contexts`, by material id, rebuilt when the manager's list moves.
+     *
+     * @param {ShadeMaterial[]} drawn
+     * @param {GPUMaterialContext[]} contexts what the manager answers for `drawn`
+     * @returns {Uint32Array}
+     */
+    #slot_table(drawn, contexts) {
+        let slots = this.#slot_tables.get(drawn);
+
+        if (slots === undefined) {
+            slots = new MaterialSlotTable();
+
+            this.#slot_tables.set(drawn, slots);
+        }
+
+        const version = this.#materials.gbuffer_contexts_version;
+
+        if (slots.version !== version) {
+            const count = contexts.length;
+            const ids = this.#slot_ids;
+
+            ids.length = count;
+
+            for (let i = 0; i < count; i++) {
+                ids[i] = contexts[i].material_id;
+            }
+
+            let table = slots.table;
+
+            const word_count = cpu_hash_table_word_count(count);
+
+            if (table.length < word_count) {
+                table = new Uint32Array(word_count);
+            }
+
+            while (!cpu_hash_table_create(table, ids, count)) {
+                table = new Uint32Array(table.length * 2);
+            }
+
+            slots.table = table;
+            slots.version = version;
+        }
+
+        return slots.table;
+    }
+}

package/src/shade/renderer/material/dispatch/MATERIAL_DISPATCH_CONSTANTS.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Side of the square screen tiles a material's pixel list is ordered by, in pixels. Each
+ * (material, tile) pair has its own counter, so the classification's atomics spread over
+ * `materials × tiles` addresses rather than piling onto one per material, and a material's list
+ * comes out tile by tile, so consecutive workgroups shade neighbouring pixels.
+ *
+ * 256 is the tile size id Software classify DOOM: The Dark Ages' visibility buffer by.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_TILE_SIZE: number;
+/**
+ * Lanes in one workgroup of the compute material dispatch, a lane per pixel. A workgroup only ever
+ * holds quads of the one material its dispatch is for, so every resource the material binds is
+ * uniform across it; the last workgroup of each material is the only partial one, and the workgroups
+ * a folded grid launches past it leave at once.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_GROUP_SIZE: number;
+/**
+ * 2×2 quads of pixels one workgroup of the compute material dispatch shades: the lists hold quads,
+ * because the laydown takes a screen-space derivative across one, as a fragment does.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_QUADS_PER_GROUP: number;
+/**
+ * Side, in 2×2 quads, of the square block one classification workgroup reads, a lane per quad. A
+ * subgroup covers a few rows of neighbouring quads, so most hold one or two materials and aggregate
+ * their atomics to as many.
+ *
+ * @type {number}
+ */
+export const MATERIAL_CLASSIFY_GROUP_SIDE: number;
+/**
+ * Side, in pixels, of the block one classification workgroup reads.
+ *
+ * @type {number}
+ */
+export const MATERIAL_CLASSIFY_BLOCK_SIZE: number;
+/**
+ * Bytes between consecutive materials' records in the dispatch record buffer: each record is bound
+ * as its own uniform, and a uniform binding's offset must be a multiple of
+ * `minUniformBufferOffsetAlignment`, which WebGPU guarantees to be at most 256.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_RECORD_STRIDE: number;
+//# sourceMappingURL=MATERIAL_DISPATCH_CONSTANTS.d.ts.map

package/src/shade/renderer/material/dispatch/MATERIAL_DISPATCH_CONSTANTS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MATERIAL_DISPATCH_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/MATERIAL_DISPATCH_CONSTANTS.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;GAOG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,gDAFU,MAAM,CAEkE;AAElF;;;;;;GAMG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,2CAFU,MAAM,CAE6D;AAE7E;;;;;;GAMG;AACH,8CAFU,MAAM,CAEmC"}

package/src/shade/renderer/material/dispatch/MATERIAL_DISPATCH_CONSTANTS.js

@@ -0,0 +1,54 @@
+/**
+ * Side of the square screen tiles a material's pixel list is ordered by, in pixels. Each
+ * (material, tile) pair has its own counter, so the classification's atomics spread over
+ * `materials × tiles` addresses rather than piling onto one per material, and a material's list
+ * comes out tile by tile, so consecutive workgroups shade neighbouring pixels.
+ *
+ * 256 is the tile size id Software classify DOOM: The Dark Ages' visibility buffer by.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_TILE_SIZE = 256;
+
+/**
+ * Lanes in one workgroup of the compute material dispatch, a lane per pixel. A workgroup only ever
+ * holds quads of the one material its dispatch is for, so every resource the material binds is
+ * uniform across it; the last workgroup of each material is the only partial one, and the workgroups
+ * a folded grid launches past it leave at once.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_GROUP_SIZE = 64;
+
+/**
+ * 2×2 quads of pixels one workgroup of the compute material dispatch shades: the lists hold quads,
+ * because the laydown takes a screen-space derivative across one, as a fragment does.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_QUADS_PER_GROUP = MATERIAL_DISPATCH_GROUP_SIZE / 4;
+
+/**
+ * Side, in 2×2 quads, of the square block one classification workgroup reads, a lane per quad. A
+ * subgroup covers a few rows of neighbouring quads, so most hold one or two materials and aggregate
+ * their atomics to as many.
+ *
+ * @type {number}
+ */
+export const MATERIAL_CLASSIFY_GROUP_SIDE = 8;
+
+/**
+ * Side, in pixels, of the block one classification workgroup reads.
+ *
+ * @type {number}
+ */
+export const MATERIAL_CLASSIFY_BLOCK_SIZE = MATERIAL_CLASSIFY_GROUP_SIDE * 2;
+
+/**
+ * Bytes between consecutive materials' records in the dispatch record buffer: each record is bound
+ * as its own uniform, and a uniform binding's offset must be a multiple of
+ * `minUniformBufferOffsetAlignment`, which WebGPU guarantees to be at most 256.
+ *
+ * @type {number}
+ */
+export const MATERIAL_DISPATCH_RECORD_STRIDE = 256;