@woosh/meep-engine 3.60.4 → 3.60.5

package/src/shade/renderer/geometry/virtual/proxy/vgeo_to_proxy_mesh.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Turn a virtual geometry into an ordinary meshlet geometry of at most `triangle_limit` triangles: a
+ * proxy, for whatever wants a plain mesh of an asset that is only clusters.
+ *
+ * **No simplification happens here.** The DAG already holds the asset at every level of detail; the
+ * proxy is a cut through it, and the cut's clusters are meshlets already (`VGEO_FORMAT.md` §8). The
+ * cut starts at the roots and refines, one group at a time, the group whose parents carry the largest
+ * `self_error`, and stops at the first refinement that would take it over the limit — so the error is
+ * as uniform as the DAG allows.
+ *
+ * A group is refined only once every one of its parents is in the cut (`group_parent_count`, §6), and
+ * then all of them are replaced together, so the cut is watertight at every step, as a view's cut is.
+ *
+ * Pages are installed as the descent reaches them, down to one band below the cut: a small proxy of a
+ * large asset reads the coarse prefix of the file and nothing else.
+ *
+ * The DAG's roots are as coarse as it goes: a limit below the roots' triangle count gets the roots.
+ *
+ * @param {VGeoContainerReader} reader an open container, which is one material's geometry; the pages the
+ *     descent reaches are installed into it and left there
+ * @param {number} triangle_limit
+ * @returns {Promise<MeshletGeometry>}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_to_proxy_mesh(reader: VGeoContainerReader, triangle_limit: number): Promise<MeshletGeometry>;
+export type VGeoContainerReader = import("../format/read/VGeoContainerReader.js").VGeoContainerReader;
+export type VGeoPage = import("../format/read/VGeoPage.js").VGeoPage;
+import { MeshletGeometry } from "../../MeshletGeometry.js";
+//# sourceMappingURL=vgeo_to_proxy_mesh.d.ts.map

package/src/shade/renderer/geometry/virtual/proxy/vgeo_to_proxy_mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_to_proxy_mesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/proxy/vgeo_to_proxy_mesh.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CARW,mBAAmB,kBAEnB,MAAM,GACJ,QAAQ,eAAe,CAAC,CAcpC;kCA7CY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ;gCAP1B,0BAA0B"}

package/src/shade/renderer/geometry/virtual/proxy/vgeo_to_proxy_mesh.js

@@ -0,0 +1,343 @@
+import { assert } from "../../../../../core/assert.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
+import { IndexedFloatMaxHeap } from "../../../../../core/collection/heap/IndexedFloatMaxHeap.js";
+import { aabb3_array_combine } from "../../../../../core/geom/3d/aabb/aabb3_array_combine.js";
+import { blas_from_meshlets } from "../../blas_from_meshlets.js";
+import { MESHLET_METADATA_STRUCT } from "../../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { MeshletGeometry } from "../../MeshletGeometry.js";
+import { VGEO_NO_CHILD } from "../format/cluster/VGEO_NO_CHILD.js";
+import { VGEO_SAME_PAGE } from "../format/cluster/VGEO_SAME_PAGE.js";
+import { vgeo_meshlet_metadata_write } from "../runtime/vgeo_meshlet_metadata_write.js";
+
+/**
+ * @typedef {import("../format/read/VGeoContainerReader.js").VGeoContainerReader} VGeoContainerReader
+ * @typedef {import("../format/read/VGeoPage.js").VGeoPage} VGeoPage
+ */
+
+/**
+ * A page not yet given its groups' ids.
+ * @type {number}
+ */
+const NO_BASE = -1;
+
+/**
+ * Turn a virtual geometry into an ordinary meshlet geometry of at most `triangle_limit` triangles: a
+ * proxy, for whatever wants a plain mesh of an asset that is only clusters.
+ *
+ * **No simplification happens here.** The DAG already holds the asset at every level of detail; the
+ * proxy is a cut through it, and the cut's clusters are meshlets already (`VGEO_FORMAT.md` §8). The
+ * cut starts at the roots and refines, one group at a time, the group whose parents carry the largest
+ * `self_error`, and stops at the first refinement that would take it over the limit — so the error is
+ * as uniform as the DAG allows.
+ *
+ * A group is refined only once every one of its parents is in the cut (`group_parent_count`, §6), and
+ * then all of them are replaced together, so the cut is watertight at every step, as a view's cut is.
+ *
+ * Pages are installed as the descent reaches them, down to one band below the cut: a small proxy of a
+ * large asset reads the coarse prefix of the file and nothing else.
+ *
+ * The DAG's roots are as coarse as it goes: a limit below the roots' triangle count gets the roots.
+ *
+ * @param {VGeoContainerReader} reader an open container, which is one material's geometry; the pages the
+ *     descent reaches are installed into it and left there
+ * @param {number} triangle_limit
+ * @returns {Promise<MeshletGeometry>}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export async function vgeo_to_proxy_mesh(reader, triangle_limit) {
+    assert.defined(reader.root, 'reader.root — the container must be open');
+    assert.isNonNegativeInteger(triangle_limit, 'triangle_limit');
+
+    const cut = new ProxyCut(reader);
+
+    await cut.descend(triangle_limit);
+
+    return cut.build();
+}
+
+/**
+ * The cut, and the bookkeeping of its descent.
+ *
+ * Groups are given dense ids as their page is installed, so the per-group state is typed arrays sized
+ * once from the header's `total_groups`.
+ */
+class ProxyCut {
+    /**
+     * @param {VGeoContainerReader} reader
+     */
+    constructor(reader) {
+        this.reader = reader;
+
+        const capacity = reader.header.total_groups;
+
+        /**
+         * First group id of each page; {@link NO_BASE} until the page is installed.
+         */
+        this.page_base = new Int32Array(reader.header.total_pages).fill(NO_BASE);
+
+        this.next_base = 0;
+
+        this.group_page = new Uint32Array(capacity);
+        this.group_index = new Uint16Array(capacity);
+
+        /**
+         * Parents of the group in the cut so far.
+         */
+        this.arrived = new Uint16Array(capacity);
+
+        /**
+         * Their triangles: what refining the group takes out of the cut.
+         */
+        this.parent_triangles = new Uint32Array(capacity);
+
+        this.refined = new Uint8Array(capacity);
+
+        /**
+         * Groups whose every parent is in the cut, by the error those parents carry.
+         */
+        this.refinable = new IndexedFloatMaxHeap(capacity);
+
+        /**
+         * Every cluster that entered the cut, as the id of its group, its index in its page and the id
+         * of its child group (-1 for a leaf). One leaves the cut when its child group is refined.
+         * @type {number[]}
+         */
+        this.entered_group = [];
+        this.entered_cluster = [];
+        this.entered_child = [];
+
+        this.triangle_count = 0;
+    }
+
+    /**
+     * @param {number} limit
+     * @returns {Promise<void>}
+     */
+    async descend(limit) {
+        const root = this.reader.root;
+
+        this.#register(root);
+
+        for (let group = 0; group < root.group_parent_count.length; group++) {
+            // no cluster refines into it: the top of the DAG
+            if (root.group_parent_count[group] === 0) {
+                await this.#enter(this.page_base[root.index] + group);
+            }
+        }
+
+        const refinable = this.refinable;
+
+        while (refinable.size > 0) {
+            const id = refinable.pop_max();
+
+            if (this.triangle_count - this.parent_triangles[id] + this.#group_triangles(id) > limit) {
+                // the largest error left does not fit: refining anywhere finer would make it less uniform
+                break;
+            }
+
+            this.refined[id] = 1;
+            this.triangle_count -= this.parent_triangles[id];
+
+            await this.#enter(id);
+        }
+    }
+
+    /**
+     * The cut's clusters as a meshlet geometry: their payloads gathered as they are stored, a metadata
+     * row each, and the BVH the mesh path builds.
+     *
+     * @returns {MeshletGeometry}
+     */
+    build() {
+        /** @type {VGeoPage[]} */
+        const pages = [];
+        /** @type {number[]} */
+        const clusters = [];
+
+        let data_size = 0;
+
+        for (let i = 0; i < this.entered_group.length; i++) {
+            const child = this.entered_child[i];
+
+            if (child !== -1 && this.refined[child] === 1) {
+                continue;
+            }
+
+            const page = this.reader.page(this.group_page[this.entered_group[i]]);
+            const cluster = this.entered_cluster[i];
+
+            pages.push(page);
+            clusters.push(cluster);
+
+            data_size += page.cluster_payload_size[cluster];
+        }
+
+        const count = clusters.length;
+
+        const data = new Uint8Array(data_size);
+
+        const metadata = BinaryBuffer.fromEndianness(platform_compute_endianness());
+
+        metadata.setCapacity(count * MESHLET_METADATA_STRUCT.size);
+
+        const result = new MeshletGeometry();
+
+        const box = result.bounding_box;
+
+        box.set([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
+
+        let address = 0;
+
+        for (let i = 0; i < count; i++) {
+            const page = pages[i];
+            const cluster = clusters[i];
+
+            const start = page.payload_offset + page.cluster_payload_offset[cluster];
+            const size = page.cluster_payload_size[cluster];
+
+            data.set(page.bytes.subarray(start, start + size), address);
+
+            // §11.8: every payload size is a multiple of four, so each cluster starts on a word
+            vgeo_meshlet_metadata_write(metadata, page, cluster, address >>> 2);
+
+            // `aabb` is the cluster's tight fit, so their union is the proxy's
+            aabb3_array_combine(box, 0, box, 0, page.aabb, cluster * 6);
+
+            address += size;
+        }
+
+        const batch = result.meshlets;
+
+        batch.count = count;
+        batch.data_buffer = data.buffer;
+        batch.metadata_buffer = metadata.data.slice(0, count * MESHLET_METADATA_STRUCT.size);
+
+        // the box-diagonal sphere `meshlet_geometry_build_from_geometry` gives a mesh
+        const sphere = result.bounding_sphere;
+
+        sphere[0] = (box[0] + box[3]) * 0.5;
+        sphere[1] = (box[1] + box[4]) * 0.5;
+        sphere[2] = (box[2] + box[5]) * 0.5;
+        sphere[3] = 0.5 * Math.hypot(box[3] - box[0], box[4] - box[1], box[5] - box[2]);
+
+        result.name = this.reader.source.name;
+        result.primitive_count = this.triangle_count;
+        result.bvh = blas_from_meshlets(batch, result.primitive_count, box);
+
+        return result;
+    }
+
+    /**
+     * @param {number} id
+     * @returns {number}
+     */
+    #group_triangles(id) {
+        const page = this.reader.page(this.group_page[id]);
+        const group = this.group_index[id];
+
+        const first = page.group_cluster_first[group];
+        const end = first + page.group_cluster_count[group];
+
+        let triangles = 0;
+
+        for (let cluster = first; cluster < end; cluster++) {
+            triangles += page.triangle_count[cluster];
+        }
+
+        return triangles;
+    }
+
+    /**
+     * Give an installed page's groups their ids.
+     *
+     * @param {VGeoPage} page
+     */
+    #register(page) {
+        if (this.page_base[page.index] !== NO_BASE) {
+            return;
+        }
+
+        const base = this.next_base;
+        const group_count = page.group_cluster_count.length;
+
+        this.page_base[page.index] = base;
+
+        for (let group = 0; group < group_count; group++) {
+            this.group_page[base + group] = page.index;
+            this.group_index[base + group] = group;
+        }
+
+        this.next_base = base + group_count;
+    }
+
+    /**
+     * Put a group's clusters in the cut, and count each in at its child group, which becomes
+     * refinable once its last parent arrives.
+     *
+     * @param {number} id
+     * @returns {Promise<void>}
+     */
+    async #enter(id) {
+        const reader = this.reader;
+        const page = reader.page(this.group_page[id]);
+        const group = this.group_index[id];
+
+        const first = page.group_cluster_first[group];
+        const end = first + page.group_cluster_count[group];
+
+        // the child pages first: a child group's parent count lives in its own page
+        const installs = [];
+
+        for (let cluster = first; cluster < end; cluster++) {
+            const child_ref = page.child_ref[cluster];
+
+            if (child_ref === VGEO_NO_CHILD || child_ref === VGEO_SAME_PAGE) {
+                continue;
+            }
+
+            const child_page = page.child_page_index[child_ref];
+
+            if (!reader.is_resident(child_page)) {
+                installs.push(reader.install(
+                    child_page, page.child_frame_offset[child_ref], page.child_fetch_size[child_ref]
+                ));
+            }
+        }
+
+        for (const child_page of await Promise.all(installs)) {
+            this.#register(child_page);
+        }
+
+        for (let cluster = first; cluster < end; cluster++) {
+            const triangles = page.triangle_count[cluster];
+
+            this.triangle_count += triangles;
+
+            this.entered_group.push(id);
+            this.entered_cluster.push(cluster);
+
+            const child_ref = page.child_ref[cluster];
+
+            if (child_ref === VGEO_NO_CHILD) {
+                this.entered_child.push(-1);
+                continue;
+            }
+
+            const child_page = reader.page(child_ref === VGEO_SAME_PAGE ? page.index : page.child_page_index[child_ref]);
+            const child_group = page.child_group[cluster];
+            const child = this.page_base[child_page.index] + child_group;
+
+            this.entered_child.push(child);
+
+            this.arrived[child]++;
+            this.parent_triangles[child] += triangles;
+
+            if (this.arrived[child] === child_page.group_parent_count[child_group]) {
+                this.refinable.insert(child, page.self_error[cluster]);
+            }
+        }
+    }
+}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_meshlet_metadata_write.d.ts

@@ -0,0 +1,17 @@
+/**
+ * One cluster's meshlet metadata row, written at `buffer`'s position.
+ *
+ * `VGEO_FORMAT.md` §8: the 40-byte rows are synthesized from the cluster record — `aabb` becomes
+ * `bounds_box`, the u8 counts widen to u32, `encoding_flags` passes through. Only `address` depends
+ * on where the payload went, so the caller says.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {VGeoPage} page
+ * @param {number} cluster index within `page`
+ * @param {number} address where the cluster's payload starts in the data the row will be read against, in 4-byte words
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_meshlet_metadata_write(buffer: BinaryBuffer, page: VGeoPage, cluster: number, address: number): void;
+//# sourceMappingURL=vgeo_meshlet_metadata_write.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/vgeo_meshlet_metadata_write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_meshlet_metadata_write.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_meshlet_metadata_write.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,2FANW,MAAM,WACN,MAAM,QAahB"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_meshlet_metadata_write.js

@@ -0,0 +1,29 @@
+import { write_wgsl_type_value } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
+import {
+    MESHLET_METADATA_STRUCT
+} from "../../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+
+/**
+ * One cluster's meshlet metadata row, written at `buffer`'s position.
+ *
+ * `VGEO_FORMAT.md` §8: the 40-byte rows are synthesized from the cluster record — `aabb` becomes
+ * `bounds_box`, the u8 counts widen to u32, `encoding_flags` passes through. Only `address` depends
+ * on where the payload went, so the caller says.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {VGeoPage} page
+ * @param {number} cluster index within `page`
+ * @param {number} address where the cluster's payload starts in the data the row will be read against, in 4-byte words
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_meshlet_metadata_write(buffer, page, cluster, address) {
+    write_wgsl_type_value({
+        bounds_box: page.aabb.subarray(cluster * 6, cluster * 6 + 6),
+        address,
+        primitive_count: page.triangle_count[cluster],
+        vertex_count: page.vertex_count[cluster],
+        flags: page.encoding_flags[cluster],
+    }, buffer, MESHLET_METADATA_STRUCT);
+}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_meshlet_batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_runtime_meshlet_batch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_meshlet_batch.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4DALa,YAAY,CA6CxB;6BA9D4B,+BAA+B"}
+{"version":3,"file":"vgeo_runtime_meshlet_batch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_meshlet_batch.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4DALa,YAAY,CAuCxB;6BAzD4B,+BAA+B"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_meshlet_batch.js

@@ -1,11 +1,11 @@
 import { assert } from "../../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
-import { write_wgsl_type_value } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
 import {
     MESHLET_METADATA_STRUCT
 } from "../../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { MeshletBatch } from "../../meshlet/MeshletBatch.js";
+import { vgeo_meshlet_metadata_write } from "./vgeo_meshlet_metadata_write.js";
 
 /**
  * A decoded page, as the meshlet pool takes it.
@@ -46,18 +46,12 @@ export function vgeo_runtime_meshlet_batch(page) {
     metadata.setCapacity(count * MESHLET_METADATA_STRUCT.size);
 
     for (let cluster = 0; cluster < count; cluster++) {
-        write_wgsl_type_value({
-            bounds_box: page.aabb.subarray(cluster * 6, cluster * 6 + 6),
-            /*
-             Words, and relative to the page's payload section — `GPUMeshletManager` adds the
-             allocation's own offset when it uploads. Format §11.8 makes every payload offset a
-             multiple of four, so this division is exact rather than rounded.
-             */
-            address: page.cluster_payload_offset[cluster] >>> 2,
-            primitive_count: page.triangle_count[cluster],
-            vertex_count: page.vertex_count[cluster],
-            flags: page.encoding_flags[cluster],
-        }, metadata, MESHLET_METADATA_STRUCT);
+        /*
+         Words, and relative to the page's payload section — `GPUMeshletManager` adds the
+         allocation's own offset when it uploads. Format §11.8 makes every payload offset a
+         multiple of four, so this division is exact rather than rounded.
+         */
+        vgeo_meshlet_metadata_write(metadata, page, cluster, page.cluster_payload_offset[cluster] >>> 2);
     }
 
     // `BinaryBuffer.data` is the ArrayBuffer itself, and `setCapacity` may have rounded it up;

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

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aAkGhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBArcY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aA2FhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBA9bY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -180,12 +180,6 @@ export class GPUProbeClipmapGI {
 
         const scene = view.scene;
         const sdf = scene.geometries.sdf;
-        const materials = this.#graphics.materials_resident;
-
-        // the scene's materials as they are this frame: a repack recaptures its pairs
-        materials.ensure_scene_materials(scene);
-        materials.update();
-
         sdf.configure(settings.mesh_sdf_voxel_size, settings.mesh_sdf_max_bricks);
         sdf.trim();
         sdf.cards.capture_mode = settings.card_capture_mode;
@@ -193,7 +187,7 @@ export class GPUProbeClipmapGI {
             graph,
             budget: settings.mesh_sdf_bake_budget,
             capture_budget: settings.card_capture_budget,
-            materials,
+            materials: this.#graphics.materials_resident,
             material_contexts: this.#graphics.materials,
         });
 
@@ -235,7 +229,6 @@ export class GPUProbeClipmapGI {
             brick_clipmap: this.#brick_clipmap,
             bricks,
             scene,
-            materials,
             card_rows: this.#holds.rows_buffer,
             resampling: settings.resampling,
         });

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

@@ -15,8 +15,8 @@
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
  * drawing is never let go in between.
  *
- * When the resident material context repacks a material whose version moved, each of that
- * material's pairs is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * When the material manager restages a material whose version moved, each of that material's pairs
+ * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
  *
  * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
  * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
@@ -25,7 +25,7 @@
 export class ProbeClipmapSceneHolds {
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
      */
     constructor(scene: GPUSceneContext, graphics: GraphicsContext);
     /**
@@ -43,7 +43,7 @@ export class ProbeClipmapSceneHolds {
      */
     get pair_count(): number;
     /**
-     * Recaptures asked for, a pair each time its material was repacked.
+     * Recaptures asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested(): number;
@@ -79,6 +79,6 @@ export type GPUSceneContext = import("../../scene/GPUSceneContext.js").GPUSceneC
 export type MeshletGeometry = import("../../geometry/MeshletGeometry.js").MeshletGeometry;
 export type GPUGeometryMetadata = import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata;
 export type ShadeMaterial = import("../../material/ShadeMaterial.js").ShadeMaterial;
-export type GPUResidentMaterialContext = import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
+export type GPUMaterialManager = import("../../material/GPUMaterialManager.js").GPUMaterialManager;
 export type GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
 //# sourceMappingURL=ProbeClipmapSceneHolds.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA1mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;8BAC1F,OAAO,0BAA0B,EAAE,eAAe"}
+{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA1mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js

@@ -10,7 +10,7 @@ import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
  * @typedef {import("../../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
  * @typedef {import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
  * @typedef {import("../../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
- * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
+ * @typedef {import("../../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 
@@ -71,8 +71,8 @@ class Pair {
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
  * drawing is never let go in between.
  *
- * When the resident material context repacks a material whose version moved, each of that
- * material's pairs is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * When the material manager restages a material whose version moved, each of that material's pairs
+ * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
  *
  * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
  * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
@@ -86,7 +86,7 @@ export class ProbeClipmapSceneHolds {
     #scene;
 
     /**
-     * @type {GPUResidentMaterialContext}
+     * @type {GPUMaterialManager}
      */
     #materials;
 
@@ -152,14 +152,14 @@ export class ProbeClipmapSceneHolds {
 
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
      */
     constructor(scene, graphics) {
         assert.defined(scene, 'scene');
         assert.defined(graphics, 'graphics');
 
         this.#scene = scene;
-        this.#materials = graphics.materials_resident;
+        this.#materials = graphics.materials;
         this.#device = graphics.device;
     }
 
@@ -187,7 +187,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * Recaptures asked for, a pair each time its material was repacked.
+     * Recaptures asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested() {
@@ -241,7 +241,7 @@ export class ProbeClipmapSceneHolds {
         this.#scene.geometries.sdf.onBaked.add(this.#baked, this);
         cards.onResident.add(this.#card_set_resident, this);
         cards.onWithdrawn.add(this.#card_set_withdrawn, this);
-        this.#materials.onMaterialRepacked.add(this.#repacked, this);
+        this.#materials.onMaterialRestaged.add(this.#restaged, this);
 
         // a row not yet written is taken now, and moved when it is
         rows.for_each_mesh((entity, geometry, material, skinned, flags) => this.#written(entity, geometry, material, flags));
@@ -263,7 +263,7 @@ export class ProbeClipmapSceneHolds {
         sdf.onBaked.remove(this.#baked, this);
         cards.onResident.remove(this.#card_set_resident, this);
         cards.onWithdrawn.remove(this.#card_set_withdrawn, this);
-        this.#materials.onMaterialRepacked.remove(this.#repacked, this);
+        this.#materials.onMaterialRestaged.remove(this.#restaged, this);
 
         for (const [entity, record] of this.#held) {
             sdf.release(record, this.#pair_of.get(entity).two_sided);
@@ -524,7 +524,7 @@ export class ProbeClipmapSceneHolds {
     /**
      * @param {ShadeMaterial} material
      */
-    #repacked(material) {
+    #restaged(material) {
         const of_material = this.#pairs_of_material.get(material.id);
 
         if (of_material === undefined) {

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts

@@ -156,13 +156,11 @@ export class GPUProbeClipmap {
      *   the update orders after
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
      *   light and shade: its lights, its environment, its rows and their geometry caches' cards
-     * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
-     *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
      * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
      *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, resampling }: {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, resampling }: {
         graph: FrameGraph;
         x: number;
         y: number;
@@ -178,7 +176,6 @@ export class GPUProbeClipmap {
         brick_clipmap: import("../brick/GPUBrickClipmap.js").GPUBrickClipmap;
         bricks: number;
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
-        materials: import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
         card_rows: GPUBuffer;
         resampling: boolean;
     }): void;