@woosh/meep-engine 3.21.0 → 3.22.0

package/src/shade/renderer/geometry/virtual/format/read/VGeoContainerReader.js

@@ -1,6 +1,8 @@
 import { assert } from "../../../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
 import { vgeo_compute_frame_checksum } from "../checksum/vgeo_compute_frame_checksum.js";
+import { VGEO_NO_CHILD } from "../cluster/VGEO_NO_CHILD.js";
+import { VGEO_SAME_PAGE } from "../cluster/VGEO_SAME_PAGE.js";
 import { VGEO_FRAME_OFFSET } from "../frame/VGEO_FRAME_OFFSET.js";
 import { vgeo_read_frame_extent } from "../frame/vgeo_read_frame_extent.js";
 import { vgeo_validate_container } from "../vgeo_validate_container.js";
@@ -33,6 +35,13 @@ const LE = true;
  * more, {@link evict} drops one, and a {@link VGeoPage} owns its own bytes and tables so that
  * dropping it drops everything it cost.
  *
+ * **Selectability is the other half of it, and it is not the same question.** {@link is_selectable}
+ * answers §10's activation invariant — whether a group's *entire ancestor cone* is here, not merely
+ * its own bytes — held as one counter per resident group. A traversal that clamps on residency
+ * instead refines into a group through the parents that arrived while a coarse cluster still stands
+ * in for one that did not, and draws both over the same surface. That is what activation is for, and
+ * it is why installing a page does bookkeeping rather than only filling a map.
+ *
  * **Validation is not on this path.** The mandatory reject rules of §4 and §10 are applied
  * unconditionally by {@link vgeo_read_header} and {@link vgeo_read_page} — a file whose magic,
  * versions, encoding or codec this build does not understand is refused rather than misread. The
@@ -95,6 +104,41 @@ export class VGeoContainerReader {
      */
     #resident_bytes = 0;
 
+    /**
+     * Live references into each resident page's groups, one counter per group.
+     *
+     * §10's activation counter. A reference is live when the cluster making it sits in an installed
+     * page *and* in a group that is itself selectable, so the counter reaching a group's
+     * `parent_cluster_count` means its entire ancestor cone is here — which is the closure the cut
+     * rule needs, held as one number per group instead of a dependency list.
+     *
+     * @type {Map<number, Uint16Array>}
+     */
+    #live_refs = new Map();
+
+    /**
+     * Which groups of each resident page are selectable, one byte per group.
+     *
+     * Derived from {@link #live_refs} and flipped by {@link #cascade_activate}, not recomputed: a
+     * traversal reads this per cluster and residency changes far less often than a frame does.
+     *
+     * @type {Map<number, Uint8Array>}
+     */
+    #selectable = new Map();
+
+    /**
+     * Live references made *into pages that are not here yet*, by page index and then by group.
+     *
+     * The reverse-reference index §10 asks for. A page cannot be told about a reference into it
+     * before it exists, and recomputing the whole closure on every install would make activation
+     * cost the resident set rather than the arrival — so the references wait here, and installing
+     * the page starts its counters from the truth. Evicting a page moves its counters back here for
+     * the same reason: the parents making those references are still resident and still selectable.
+     *
+     * @type {Map<number, Map<number, number>>}
+     */
+    #pending_refs = new Map();
+
     /**
      * @param {VGeoByteSource} source
      * @param {VGeoReadOptions} [options]
@@ -267,6 +311,265 @@ export class VGeoContainerReader {
         return this.#pages.has(page_index);
     }
 
+    /**
+     * Whether a group may be selected from — §10's activation invariant, and **not** the same
+     * question as {@link is_resident}.
+     *
+     * A group is selectable iff every one of its `parent_cluster_count` references is live: the
+     * referencing cluster's page is installed and that cluster's own group is selectable. Groups
+     * with no parents at all — exactly the root page's topmost level — are selectable the moment
+     * their page is.
+     *
+     * The distinction is load-bearing and it is invisible until an asset is big enough to put one
+     * group's parents in two pages. Refining into a group whose page merely *arrived* draws it
+     * underneath the coarse cluster still standing in for the parent that did not, and the two
+     * surfaces fight over the same pixels. Residency says the bytes are here; selectability says
+     * nothing above them is missing, which is what "no holes and no double-draw, in any arrival
+     * order" actually rests on.
+     *
+     * Synchronous and total, like {@link page}: the traversal asks it per cluster and acts on a
+     * `false` by clamping.
+     *
+     * @param {number} page_index
+     * @param {number} group index within that page
+     * @returns {boolean}
+     */
+    is_selectable(page_index, group) {
+        const selectable = this.#selectable.get(page_index);
+
+        if (selectable === undefined) {
+            return false;
+        }
+
+        return selectable[group] === 1;
+    }
+
+    /**
+     * Bring a freshly installed page into the activation state.
+     *
+     * @param {VGeoPage} page
+     */
+    #activate_page(page) {
+        const group_count = page.group_cluster_first.length;
+
+        const live = new Uint16Array(group_count);
+        const selectable = new Uint8Array(group_count);
+
+        const pending = this.#pending_refs.get(page.index);
+
+        if (pending !== undefined) {
+            for (const [group, count] of pending) {
+                if (group < group_count) {
+                    live[group] = count;
+                }
+            }
+
+            this.#pending_refs.delete(page.index);
+        }
+
+        this.#live_refs.set(page.index, live);
+        this.#selectable.set(page.index, selectable);
+
+        /**
+         * Page and group index, interleaved, as {@link vgeo_select_cut}'s own stack is.
+         * @type {number[]}
+         */
+        const queue = [];
+
+        for (let group = 0; group < group_count; group++) {
+            if (live[group] === page.group_parent_count[group]) {
+                queue.push(page.index, group);
+            }
+        }
+
+        this.#cascade_activate(queue);
+    }
+
+    /**
+     * Flip the queued groups selectable, and follow their references down.
+     *
+     * A group becoming selectable makes every reference its clusters hold live, which can complete
+     * the count of a group one level down, and so on. The cascade is what lets a page arrive in any
+     * order: whatever it unblocks, it unblocks now, and whatever it does not stays clamped without
+     * anybody having to ask again.
+     *
+     * @param {number[]} queue page and group index, interleaved
+     */
+    #cascade_activate(queue) {
+        while (queue.length > 0) {
+            const group = queue.pop();
+            const page_index = queue.pop();
+
+            const page = this.#pages.get(page_index);
+            const selectable = this.#selectable.get(page_index);
+
+            if (page === undefined || selectable[group] === 1) {
+                continue;
+            }
+
+            selectable[group] = 1;
+
+            const first = page.group_cluster_first[group];
+            const count = page.group_cluster_count[group];
+
+            for (let i = 0; i < count; i++) {
+                const cluster = first + i;
+
+                const child_page = this.#child_page_of(page, cluster);
+
+                if (child_page < 0) {
+                    continue;
+                }
+
+                const child_group = page.child_group[cluster];
+
+                const live = this.#live_refs.get(child_page);
+
+                if (live === undefined) {
+                    this.#hold_reference(child_page, child_group);
+
+                    continue;
+                }
+
+                if (child_group >= live.length) {
+                    // a `child_group` outside the child page's table; the traversal reports the
+                    // broken reference, and counting it here would corrupt a neighbour's counter
+                    continue;
+                }
+
+                live[child_group]++;
+
+                if (live[child_group] === this.#pages.get(child_page).group_parent_count[child_group]) {
+                    queue.push(child_page, child_group);
+                }
+            }
+        }
+    }
+
+    /**
+     * Retract a group's selectability and everything that rested on it.
+     *
+     * The mirror of the cascade, and the reason eviction is not simply forgetting a page: a group
+     * one level down was selectable *because* of the references this one made, and leaving those
+     * counted would leave it drawable with a hole above it.
+     *
+     * @param {number} page_index
+     * @param {number} group
+     */
+    #cascade_deactivate(page_index, group) {
+        const page = this.#pages.get(page_index);
+        const selectable = this.#selectable.get(page_index);
+
+        if (page === undefined || selectable === undefined || selectable[group] !== 1) {
+            return;
+        }
+
+        selectable[group] = 0;
+
+        const first = page.group_cluster_first[group];
+        const count = page.group_cluster_count[group];
+
+        for (let i = 0; i < count; i++) {
+            const cluster = first + i;
+
+            const child_page = this.#child_page_of(page, cluster);
+
+            if (child_page < 0) {
+                continue;
+            }
+
+            const child_group = page.child_group[cluster];
+
+            const live = this.#live_refs.get(child_page);
+
+            if (live === undefined) {
+                this.#release_reference(child_page, child_group);
+
+                continue;
+            }
+
+            if (child_group >= live.length) {
+                continue;
+            }
+
+            live[child_group]--;
+
+            if (live[child_group] < this.#pages.get(child_page).group_parent_count[child_group]) {
+                this.#cascade_deactivate(child_page, child_group);
+            }
+        }
+    }
+
+    /**
+     * The page a cluster's child group lives in, or `-1` where there is none to resolve — a leaf, or
+     * a `child_ref` outside this page's child table.
+     *
+     * `SAME_PAGE` resolves to the page itself and is *not* a shortcut past activation: page-local
+     * says nothing about where the group's other parents are, and a group referenced from inside its
+     * own page can still be waiting on one that is not.
+     *
+     * @param {VGeoPage} page
+     * @param {number} cluster
+     * @returns {number}
+     */
+    #child_page_of(page, cluster) {
+        const child_ref = page.child_ref[cluster];
+
+        if (child_ref === VGEO_NO_CHILD) {
+            return -1;
+        }
+
+        if (child_ref === VGEO_SAME_PAGE) {
+            return page.index;
+        }
+
+        if (child_ref >= page.child_page_index.length) {
+            return -1;
+        }
+
+        return page.child_page_index[child_ref];
+    }
+
+    /**
+     * @param {number} page_index a page that is not resident
+     * @param {number} group
+     */
+    #hold_reference(page_index, group) {
+        let held = this.#pending_refs.get(page_index);
+
+        if (held === undefined) {
+            held = new Map();
+
+            this.#pending_refs.set(page_index, held);
+        }
+
+        held.set(group, (held.get(group) ?? 0) + 1);
+    }
+
+    /**
+     * @param {number} page_index a page that is not resident
+     * @param {number} group
+     */
+    #release_reference(page_index, group) {
+        const held = this.#pending_refs.get(page_index);
+
+        if (held === undefined) {
+            return;
+        }
+
+        const left = (held.get(group) ?? 0) - 1;
+
+        if (left > 0) {
+            held.set(group, left);
+        } else {
+            held.delete(group);
+        }
+
+        if (held.size === 0) {
+            this.#pending_refs.delete(page_index);
+        }
+    }
+
     /**
      * Fetch and install one page, from the exact range something already resident named.
      *
@@ -323,6 +626,10 @@ export class VGeoContainerReader {
             this.#pages.set(page_index, page);
 
             this.#resident_bytes += page.decoded_size;
+
+            // after the page is resident, because the cascade reads residency to decide whether a
+            // reference lands on a counter or waits in the pending index — including this page's own
+            this.#activate_page(page);
         }
 
         return this.#pages.get(page_index);
@@ -397,6 +704,44 @@ export class VGeoContainerReader {
             return false;
         }
 
+        /*
+         Retract before dropping: the references this page's selectable groups made are read out of
+         its own cluster records, and a page that has already been forgotten cannot say what it was
+         holding up. Under §10's eviction rule — a page is evictable only while it has no resident
+         child pages — this decrements nothing that is still resident and costs a walk of the page.
+         When a caller evicts against that rule anyway, the cascade is what stops a child page from
+         staying drawable with nothing above it.
+        */
+        const selectable = this.#selectable.get(page_index);
+
+        for (let group = 0; group < selectable.length; group++) {
+            this.#cascade_deactivate(page_index, group);
+        }
+
+        /*
+         References *into* this page do not go away with it — the clusters making them are in pages
+         that are still here and still selectable — so they move back to the pending index, and a
+         re-install starts its counters where they left off rather than at zero.
+        */
+        const live = this.#live_refs.get(page_index);
+
+        const held = new Map();
+
+        for (let group = 0; group < live.length; group++) {
+            if (live[group] > 0) {
+                held.set(group, live[group]);
+            }
+        }
+
+        if (held.size > 0) {
+            this.#pending_refs.set(page_index, held);
+        } else {
+            this.#pending_refs.delete(page_index);
+        }
+
+        this.#live_refs.delete(page_index);
+        this.#selectable.delete(page_index);
+
         this.#pages.delete(page_index);
 
         this.#resident_bytes -= page.decoded_size;

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.d.ts

@@ -1,12 +1,18 @@
 /**
  * Requires a fairly beefy GPU to run, confirmed to work on RTX 4090.
- * @param {Scene} scene
- * @param {Renderer} renderer
- * @param {number} [cell_size=0.5] desired cell size for the voxel grid
- * @param {number} [max_memory_usage_bytes] maximum memory usage in bytes, default is 16MB
+ * @param {Object} options
+ * @param {Scene} options.scene
+ * @param {Renderer} options.renderer
+ * @param {number} [options.cell_size=0.5] desired cell size for the voxel grid
+ * @param {number} [options.max_memory_usage_bytes] maximum memory usage in bytes, default is 16MB
  * @returns {Promise<{tree: Brick4IntermediateNode, binary: ArrayBuffer}>}
  */
-export function brick4_bake_for_scene({ scene, renderer, cell_size, max_memory_usage_bytes, }: Scene): Promise<{
+export function brick4_bake_for_scene({ scene, renderer, cell_size, max_memory_usage_bytes, }: {
+    scene: Scene;
+    renderer: Renderer;
+    cell_size?: number;
+    max_memory_usage_bytes?: number;
+}): Promise<{
     tree: Brick4IntermediateNode;
     binary: ArrayBuffer;
 }>;

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brick4_bake_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,uGAFa,QAAQ;IAAC,IAAI,yBAAyB;IAAC,MAAM,EAAE,WAAW,CAAA;CAAC,CAAC,CA2DxE"}
+{"version":3,"file":"brick4_bake_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH;IAN0B,KAAK;IACF,QAAQ;IACT,SAAS,GAA1B,MAAM;IACW,sBAAsB,GAAvC,MAAM;IACJ,QAAQ;IAAC,IAAI,yBAAyB;IAAC,MAAM,EAAE,WAAW,CAAA;CAAC,CAAC,CA2DxE"}

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.js

@@ -8,10 +8,11 @@ import { brick4_to_gpu_structure } from "./brick4_to_gpu_structure.js";
 
 /**
  * Requires a fairly beefy GPU to run, confirmed to work on RTX 4090.
- * @param {Scene} scene
- * @param {Renderer} renderer
- * @param {number} [cell_size=0.5] desired cell size for the voxel grid
- * @param {number} [max_memory_usage_bytes] maximum memory usage in bytes, default is 16MB
+ * @param {Object} options
+ * @param {Scene} options.scene
+ * @param {Renderer} options.renderer
+ * @param {number} [options.cell_size=0.5] desired cell size for the voxel grid
+ * @param {number} [options.max_memory_usage_bytes] maximum memory usage in bytes, default is 16MB
  * @returns {Promise<{tree: Brick4IntermediateNode, binary: ArrayBuffer}>}
  */
 export async function brick4_bake_for_scene({

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.d.ts

@@ -1,11 +1,18 @@
 /**
  * Generate a "brick" tree, where each node is a 4x4x4 probe volume.
  *
- * @param {Scene} scene
- * @param {StaticSceneBVH} bvh
- * @param {number} [cell_size] size of the smallest cell in world units
- * @param {number} [max_memory_usage_bytes] upper limit of how much total memory the entire tree will take up, including probe data
+ * @param {Object} options
+ * @param {Scene} options.scene
+ * @param {StaticSceneBVH} options.bvh
+ * @param {number} [options.cell_size] size of the smallest cell in world units
+ * @param {number} [options.max_memory_usage_bytes] upper limit of how much total memory the entire tree will take up, including probe data
  */
-export function brick4_generate_tree_from_scene({ scene, bvh, cell_size, max_memory_usage_bytes, }: Scene): Brick4IntermediateNode;
+export function brick4_generate_tree_from_scene({ scene, bvh, cell_size, max_memory_usage_bytes, }: {
+    scene: Scene;
+    bvh: StaticSceneBVH;
+    cell_size?: number;
+    max_memory_usage_bytes?: number;
+}): Brick4IntermediateNode;
+import { StaticSceneBVH } from "../../../scene/bvh/StaticSceneBVH.js";
 import { Brick4IntermediateNode } from "./Brick4IntermediateNode.js";
 //# sourceMappingURL=brick4_generate_tree_from_scene.d.ts.map

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brick4_generate_tree_from_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.js"],"names":[],"mappings":"AAyKA;;;;;;;GAOG;AACH,mIAkbC;uCAhlBsC,6BAA6B"}
+{"version":3,"file":"brick4_generate_tree_from_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AACH;IAL0B,KAAK;IACI,GAAG,EAA3B,cAAc;IACG,SAAS,GAA1B,MAAM;IACW,sBAAsB,GAAvC,MAAM;2BAobhB;+BA1lB8B,sCAAsC;uCAS9B,6BAA6B"}

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.js

@@ -170,10 +170,11 @@ function purge_partial_depths(root, expansion_candidates) {
 /**
  * Generate a "brick" tree, where each node is a 4x4x4 probe volume.
  *
- * @param {Scene} scene
- * @param {StaticSceneBVH} bvh
- * @param {number} [cell_size] size of the smallest cell in world units
- * @param {number} [max_memory_usage_bytes] upper limit of how much total memory the entire tree will take up, including probe data
+ * @param {Object} options
+ * @param {Scene} options.scene
+ * @param {StaticSceneBVH} options.bvh
+ * @param {number} [options.cell_size] size of the smallest cell in world units
+ * @param {number} [options.max_memory_usage_bytes] upper limit of how much total memory the entire tree will take up, including probe data
  */
 export function brick4_generate_tree_from_scene({
                                                     scene,

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.d.ts

@@ -1,9 +1,15 @@
 /**
  *
- * @param {Brick4IntermediateNode} brick4
- * @param {GraphicsContext} graphics
- * @param {StaticSceneBVH} bvh
- * @param {GPUSceneContext} scene
+ * @param {Object} options
+ * @param {Brick4IntermediateNode} options.brick4
+ * @param {GraphicsContext} options.graphics
+ * @param {StaticSceneBVH} options.bvh
+ * @param {GPUSceneContext} options.scene
  */
-export function brick4_bake_basic({ brick4, graphics, bvh, scene }: Brick4IntermediateNode): Promise<Uint32Array>;
+export function brick4_bake_basic({ brick4, graphics, bvh, scene }: {
+    brick4: Brick4IntermediateNode;
+    graphics: GraphicsContext;
+    bvh: StaticSceneBVH;
+    scene: GPUSceneContext;
+}): Promise<Uint32Array>;
 //# sourceMappingURL=brick4_bake_basic.d.ts.map

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brick4_bake_basic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,kHAgMC"}
+{"version":3,"file":"brick4_bake_basic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js"],"names":[],"mappings":"AAoCA;;;;;;;GAOG;AACH;IAL2C,MAAM;IACb,QAAQ;IACT,GAAG;IACF,KAAK;yBAkMxC"}

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js

@@ -36,10 +36,11 @@ const QUALITY_PROFILE = {
 
 /**
  *
- * @param {Brick4IntermediateNode} brick4
- * @param {GraphicsContext} graphics
- * @param {StaticSceneBVH} bvh
- * @param {GPUSceneContext} scene
+ * @param {Object} options
+ * @param {Brick4IntermediateNode} options.brick4
+ * @param {GraphicsContext} options.graphics
+ * @param {StaticSceneBVH} options.bvh
+ * @param {GPUSceneContext} options.scene
  */
 export async function brick4_bake_basic({
                                             brick4,

package/src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("./LightProbeVolume.js").LightProbeVolume} LightProbeVolume
+ */
 export class GPULightProbeVolume {
     /**
      *
@@ -9,7 +12,7 @@ export class GPULightProbeVolume {
      *
      * @returns {LightProbeVolume}
      */
-    get source(): LightProbeVolume;
+    get source(): import("./LightProbeVolume.js").LightProbeVolume;
     /**
      *
      * @returns {GPUBuffer}
@@ -42,6 +45,7 @@ export class GPULightProbeVolume {
     debugReadProbes(): void;
     #private;
 }
+export type LightProbeVolume = import("./LightProbeVolume.js").LightProbeVolume;
 import { GPUTypedBuffer } from "../../buffer/GPUTypedBuffer.js";
 import { GPUProbeAtlas } from "../probe/octahedral/GPUProbeAtlas.js";
 //# sourceMappingURL=GPULightProbeVolume.d.ts.map

package/src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.js"],"names":[],"mappings":"AAgBA;IAsFI;;;;OAIG;IACH,yDAiCC;IArHD;;;OAGG;IACH,+BAEC;IAOD;;;OAGG;IACH,6BAEC;IAOD;;;OAGG;IACH,+BAEC;IAOD;;;OAGG;IACH,sCAEC;IAOD,iCAEC;IAoBD;;OAEG;IACH,OAFU,aAAa,CAEjB;IA4JN,oBAwDC;IAED,eAIC;IAED,eAMC;IAED,gBAKC;IAED,4BAMC;IAED;;OAEG;IACH,0BAsBC;IAED,wBAOC;;CACJ;+BApX8B,gCAAgC;8BAIjC,sCAAsC"}
+{"version":3,"file":"GPULightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.js"],"names":[],"mappings":"AAeA;;GAEG;AAGH;IAsFI;;;;OAIG;IACH,uCAFW,gBAAgB,EAmC1B;IArHD;;;OAGG;IACH,+DAEC;IAOD;;;OAGG;IACH,6BAEC;IAOD;;;OAGG;IACH,+BAEC;IAOD;;;OAGG;IACH,sCAEC;IAOD,iCAEC;IAoBD;;OAEG;IACH,OAFU,aAAa,CAEjB;IA4JN,oBAwDC;IAED,eAIC;IAED,eAMC;IAED,gBAKC;IAED,4BAMC;IAED;;OAEG;IACH,0BAsBC;IAED,wBAOC;;CACJ;+BA9WY,OAAO,uBAAuB,EAAE,gBAAgB;+BAV9B,gCAAgC;8BAIjC,sCAAsC"}

package/src/shade/renderer/global_illumination/lpv/GPULightProbeVolume.js

@@ -13,6 +13,10 @@ import { LIGHT_PROBE_STRUCT } from "./LIGHT_PROBE_STRUCT.js";
 import { LIGHT_PROBE_VOLUME_METADATA_STRUCT } from "./LIGHT_PROBE_VOLUME_METADATA_STRUCT.js";
 import { TETRAHEDRAL_MESH_CELL_STRUCT } from "./TETRAHEDRAL_MESH_CELL_STRUCT.js";
 
+/**
+ * @typedef {import("./LightProbeVolume.js").LightProbeVolume} LightProbeVolume
+ */
+
 
 export class GPULightProbeVolume {
 

package/src/shade/renderer/global_illumination/lpv/LightProbeVolume.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../../../../core/geom/Vector3.js").Vector3} Vector3
+ */
 /**
  * @typedef {import("../../../../core/geom/3d/aabb/AABB3.js").AABB3} AABB3
  */
@@ -54,6 +57,7 @@ export class LightProbeVolume {
     }): void;
     #private;
 }
+export type Vector3 = import("../../../../core/geom/Vector3.js").Vector3;
 export type AABB3 = import("../../../../core/geom/3d/aabb/AABB3.js").AABB3;
 import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
 //# sourceMappingURL=LightProbeVolume.d.ts.map

package/src/shade/renderer/global_illumination/lpv/LightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;GAEG;AACH;IASI;;;OAGG;IACH,iCAEC;IAKD;;;OAGG;IACH,4BAEC;IAUD,kCAMC;IAdD;;;OAGG;IACH,8BAEC;IAUD;;;OAGG;IACH,0BAEC;IAID;;;OAGG;IACH,sBAEC;IAED,eAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,UAehB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAiBhB;IAuBD,mBAUC;IAED;;;;OAIG;IACH,mBAHW,KAAK,cACL,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,QAchD;;CACJ;oBAjKY,OAAO,wCAAwC,EAAE,KAAK;gCAJnC,wDAAwD"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/LightProbeVolume.js"],"names":[],"mappings":"AASA;;GAEG;AAGH;;GAEG;AACH;IASI;;;OAGG;IACH,iCAEC;IAKD;;;OAGG;IACH,4BAEC;IAUD,kCAMC;IAdD;;;OAGG;IACH,8BAEC;IAUD;;;OAGG;IACH,0BAEC;IAID;;;OAGG;IACH,sBAEC;IAED,eAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,UAehB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAiBhB;IAuBD,mBAUC;IAED;;;;OAIG;IACH,mBAHW,KAAK,cACL,OAAO,GAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,QAchD;;CACJ;sBAtKY,OAAO,kCAAkC,EAAE,OAAO;oBAKlD,OAAO,wCAAwC,EAAE,KAAK;gCARnC,wDAAwD"}

package/src/shade/renderer/global_illumination/lpv/LightProbeVolume.js

@@ -7,6 +7,10 @@ import {
 } from "../../../../core/geom/3d/tetrahedra/delaunay/grid/tetrahedral_mesh_build_from_grid.js";
 import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
 
+/**
+ * @typedef {import("../../../../core/geom/Vector3.js").Vector3} Vector3
+ */
+
 
 /**
  * @typedef {import("../../../../core/geom/3d/aabb/AABB3.js").AABB3} AABB3

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
 export class GPULightProbeVolumeRenderer {
     /**
      *
@@ -35,7 +39,7 @@ export class GPULightProbeVolumeRenderer {
      *
      * @param {number} resolution
      */
-    generate_locations(resolution?: number): Promise<GPUSceneContext>;
+    generate_locations(resolution?: number): Promise<import("../../../scene/GPUSceneContext.js").GPUSceneContext>;
     /**
      *
      * @param {ShadeGPUCommandContext} [command_ctx]
@@ -57,6 +61,8 @@ export class GPULightProbeVolumeRenderer {
     destroy(): void;
     #private;
 }
+export type GraphicsContext = import("../../../GraphicsContext.js").GraphicsContext;
+export type GPUSceneContext = import("../../../scene/GPUSceneContext.js").GPUSceneContext;
 import { GPUTextureContext } from "../../../texture/GPUTextureContext.js";
 import { ShadeGPUCommandContext } from "../../../../device/ShadeGPUCommandContext.js";
 //# sourceMappingURL=GPULightProbeVolumeRenderer.d.ts.map

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;IA+GI;;;;OAIG;IACH,qEAMC;IAhCD;;;;OAIG;IACH,+DAcC;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,4BAahB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAgGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;kCAnYiC,uCAAuC;uCAFlC,8CAA8C"}
+{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAahB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAgGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BA7XY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAZtC,uCAAuC;uCAFlC,8CAA8C"}

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js

@@ -19,6 +19,11 @@ import {
 import { graph_generate_probe_locations } from "../placement/graph_generate_probe_locations.js";
 import { PROBE_RAYS_PER_WORKGROUP } from "./PROBE_RAYS_PER_WORKGROUP.js";
 
+/**
+ * @typedef {import("../../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
+
 export class GPULightProbeVolumeRenderer {
     /**
      * @type {GPUSceneContext}