@woosh/meep-engine 3.2.0 → 3.4.0

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js

@@ -2,15 +2,21 @@ import { assert } from "../../../../core/assert.js";
 import { platform_compute_endianness } from "../../../../core/binary/platform_compute_endianness.js";
 import { array_buffer_copy } from "../../../../core/collection/array/typed/array_buffer_copy.js";
 import { Deque } from "../../../../core/collection/queue/Deque.js";
-import IdPool from "../../../../core/IdPool.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { number_format_by_thousands } from "../../../../core/primitives/numbers/number_format_by_thousands.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
 import { ensure_buffer_capacity } from "../make_temp_gpu_buffer.js";
+import { bvh2_derive_topology } from "./bvh2_derive_topology.js";
 import { GPUGeometryMeshletsBVH } from "./GPUGeometryMeshletsBVH.js";
 
+/**
+ * One row of the lookup table the traversal shaders read as `blas_lookup`.
+ *
+ * The row holds the arena node index a tree's root sits at. What the table is *indexed* by is not
+ * this manager's business — see {@link GPUGeometryBVHManager#publish_lookup}.
+ */
 export const BLAS_METADATA_STRUCT = WebGPUStruct.from({
     // index of root node for BLAS
     address: u32
@@ -24,6 +30,21 @@ const DATA_GROWTH_MULTIPLIER = 1.2;
 
 const endianness = platform_compute_endianness();
 
+/**
+ * Residency for BLAS node data: one arena buffer holding every registered tree's nodes, and a
+ * lookup buffer that maps *something else's* index onto an arena address.
+ *
+ * The split matters. This manager owns arena positions — it decides where a tree's nodes land and
+ * hands back the node index of its root. It does **not** own the index space the lookup is read by:
+ * every traversal shader does `blas_lookup[geometry_index]`, and geometry indices belong to
+ * {@link GPUGeometryManager}. So the table is published by whoever owns those indices, through
+ * {@link publish_lookup}; this manager only stores and uploads it.
+ *
+ * It used to allocate the lookup rows itself, from a pool of its own in BLAS-registration order.
+ * That agrees with geometry indices exactly until something takes a geometry index without taking a
+ * BLAS row — which per-instance clones do — after which every geometry resolved to another
+ * geometry's tree. See `blas_lookup_indexing.spec.js`.
+ */
 export class GPUGeometryBVHManager {
 
     /**
@@ -59,6 +80,48 @@ export class GPUGeometryBVHManager {
      */
     #buffer_data_end = 0;
 
+    /**
+     * Parent of every node, and the node index of every leaf, for each *distinct topology* — one
+     * arena each, addressed like {@link #buffer_data}.
+     *
+     * Separate from the nodes because they are separate things. Node bounds are per instance: a
+     * skinned clone's are its own, recomputed every frame from its own deformed vertices. Parents
+     * and leaf positions are the shape of the tree, and every copy of a geometry has the same
+     * shape, so one derivation serves all of them.
+     *
+     * @type {GPUBuffer}
+     */
+    #buffer_parents;
+
+    /**
+     * @returns {GPUBuffer}
+     */
+    get buffer_parents() {
+        return this.#buffer_parents;
+    }
+
+    /**
+     * @type {GPUBuffer}
+     */
+    #buffer_leaf_nodes;
+
+    /**
+     * @returns {GPUBuffer}
+     */
+    get buffer_leaf_nodes() {
+        return this.#buffer_leaf_nodes;
+    }
+
+    #buffer_parents_end = 0;
+    #buffer_leaf_nodes_end = 0;
+
+    /**
+     * Topology by the geometry whose nodes it was derived from, shared by every copy of it.
+     *
+     * @type {Map<MeshletGeometry, {parents_offset: number, leaf_nodes_offset: number, leaf_count: number, node_count: number, resident: boolean, derived: {parents: Uint32Array, leaf_nodes: Uint32Array}}>}
+     */
+    #topology = new Map();
+
     /**
      *
      * @type {number}
@@ -82,8 +145,6 @@ export class GPUGeometryBVHManager {
      */
     #update_queue = new Deque();
 
-    #slot_pool = new IdPool();
-
     /**
      *
      * @param {GPUDevice} device
@@ -103,6 +164,18 @@ export class GPUGeometryBVHManager {
             usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
         });
 
+        this.#buffer_parents = device.createBuffer({
+            label: "GPUGeometryBVHManager/parents",
+            size: DATA_INITIAL_CAPACITY,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
+        });
+
+        this.#buffer_leaf_nodes = device.createBuffer({
+            label: "GPUGeometryBVHManager/leaf_nodes",
+            size: DATA_INITIAL_CAPACITY,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
+        });
+
     }
 
     get gpu_memory_usage() {
@@ -116,39 +189,65 @@ export class GPUGeometryBVHManager {
             r += this.#buffer_data.size;
         }
 
+        if (this.#buffer_parents) {
+            r += this.#buffer_parents.size;
+        }
+
+        if (this.#buffer_leaf_nodes) {
+            r += this.#buffer_leaf_nodes.size;
+        }
+
         return r;
     }
 
     /**
+     * The tree belonging to `owner`, registered against `source`'s shape if it does not exist yet.
      *
-     * @param {MeshletGeometry} meshlets
+     * Two arguments rather than one because those are two different questions. `owner` is the
+     * identity the tree is looked up by; `source` is the geometry whose nodes it starts as. They
+     * coincide for anything that owns its geometry outright, and they do not for a per-instance
+     * copy — a skinned clone deforms its own vertices, so its bounds are its own and cannot be
+     * written into the tree everyone else is tracing, but its *shape* is by definition the
+     * source's. Keeping the two separate is what lets one derivation serve every copy.
+     *
+     * @param {object} owner identity to look this tree up by — a geometry, a clone's metadata row
+     * @param {MeshletGeometry} source geometry whose nodes this tree takes its shape and rest-pose
+     * bounds from
      * @returns {GPUGeometryMeshletsBVH}
      */
-    obtain(meshlets) {
-        assert.equal(meshlets.isMeshletGeometry, true, 'meshlets.isMeshletGeometry !== true');
+    obtain(owner, source) {
+        assert.defined(owner, 'owner');
+        assert.equal(source.isMeshletGeometry, true, 'source.isMeshletGeometry !== true');
 
-        let bvh = this.#map.get(meshlets);
+        let bvh = this.#map.get(owner);
 
         if (bvh === undefined) {
-            bvh = this.#create(meshlets);
+            bvh = this.#register(owner, source);
         }
 
         return bvh;
     }
 
     /**
+     * Register a tree, keyed by whatever owns it.
+     *
+     * `owner` is the identity the tree is looked up by and `source` is the geometry whose nodes it
+     * holds. For an ordinary geometry those are the same object. For a per-instance copy they are
+     * not: the copy needs a node region of its own, because its bounds move independently, while
+     * the *shape* it is a copy of belongs to the source.
      *
-     * @param {MeshletGeometry} meshlets
+     * @param {object} owner
+     * @param {MeshletGeometry} source
      * @returns {GPUGeometryMeshletsBVH}
      */
-    #create(meshlets) {
+    #register(owner, source) {
 
         const bvh = new GPUGeometryMeshletsBVH();
 
-        bvh.slot = this.#slot_pool.get();
-        bvh.bvh = meshlets.bvh;
+        bvh.bvh = source.bvh;
+        bvh.topology = this.#obtain_topology(source);
 
-        this.#map.set(meshlets, bvh);
+        this.#map.set(owner, bvh);
 
         this.#update_queue.add(bvh);
 
@@ -156,16 +255,105 @@ export class GPUGeometryBVHManager {
     }
 
     /**
-     * Release a geometry's BLAS. The metadata slot is returned to the pool for reuse and the
-     * map entry is dropped. The append-only data region ({@link #buffer_data}) is not
+     * The parents/leaf-nodes derivation for a geometry, made once and shared by every tree that is
+     * a copy of it.
+     *
+     * @param {MeshletGeometry} source
+     * @returns {object} the topology record
+     */
+    #obtain_topology(source) {
+        let topology = this.#topology.get(source);
+
+        if (topology !== undefined) {
+            return topology;
+        }
+
+        // Derivation waits for {@link #upload_pending_topology}, beside the residency decision it
+        // feeds. A geometry can be registered before its BLAS bytes exist — nothing has to have
+        // built one yet — and a record that says "not resident" is the honest answer for that,
+        // rather than an empty derivation cached forever.
+        topology = {
+            source,
+            leaf_count: 0,
+            node_count: 0,
+            parents_offset: 0,
+            leaf_nodes_offset: 0,
+            resident: false,
+        };
+
+        this.#topology.set(source, topology);
+
+        return topology;
+    }
+
+    /**
+     * Everything a refit needs to find a resident tree, or `undefined` while it is not resident.
+     *
+     * @param {object} owner the identity passed to {@link obtain}
+     * @returns {{node_word_offset: number, node_count: number, leaf_count: number, parents_offset: number, leaf_nodes_offset: number}|undefined}
+     */
+    get_refit_target(owner) {
+        const bvh = this.#map.get(owner);
+
+        if (bvh === undefined || bvh.released || !bvh.resident || !bvh.topology.resident) {
+            return undefined;
+        }
+
+        return {
+            node_word_offset: bvh.address * (BVH2_NODE_STRUCT.size / Uint32Array.BYTES_PER_ELEMENT),
+            node_count: bvh.topology.node_count,
+            leaf_count: bvh.topology.leaf_count,
+            parents_offset: bvh.topology.parents_offset,
+            leaf_nodes_offset: bvh.topology.leaf_nodes_offset,
+        };
+    }
+
+    /**
+     * Where a registered tree's root sits in the arena, or `undefined` while nothing is resident
+     * for this owner — either it was never registered, or {@link update} has not run since.
+     *
+     * @param {object} owner the identity passed to {@link obtain}
+     * @returns {number|undefined} arena node index
+     */
+    get_address(owner) {
+        const bvh = this.#map.get(owner);
+
+        if (bvh === undefined || bvh.released || !bvh.resident) {
+            return undefined;
+        }
+
+        return bvh.address;
+    }
+
+    /**
+     * Publish the lookup table the traversal shaders read.
+     *
+     * `addresses[i]` is the arena node index that index `i` resolves to. What `i` means is the
+     * caller's business — today it is a geometry index, and the shaders agree because
+     * {@link GPUGeometryManager} builds the table from the same ids it stamps into the geometry
+     * metadata buffer.
+     *
+     * @param {Uint32Array} addresses
+     */
+    publish_lookup(addresses) {
+        assert.defined(addresses, 'addresses');
+
+        this.#ensure_metadata_capacity(addresses.length);
+
+        this.#device.queue.writeBuffer(this.#buffer_metadata, 0, addresses, 0, addresses.length);
+    }
+
+    /**
+     * Release an owner's BLAS: the map entry is dropped, and the next {@link publish_lookup}
+     * stops naming its arena address. The append-only data region ({@link #buffer_data}) is not
      * reclaimed — those bytes become unreferenced and are only recovered on a future buffer
      * rebuild, a bounded residual versus the previous total leak (no entry was ever freed).
      *
-     * @param {MeshletGeometry} meshlets the key passed to {@link obtain}
-     * @returns {boolean} true if a BLAS was registered for this geometry and released
+     * @param {object} owner the identity passed to {@link obtain}
+     * @returns {boolean} true if a BLAS was registered for this owner and released
      */
-    remove(meshlets) {
-        const bvh = this.#map.get(meshlets);
+    remove(owner) {
+        const bvh = this.#map.get(owner);
 
         if (bvh === undefined) {
             return false;
@@ -175,12 +363,38 @@ export class GPUGeometryBVHManager {
         // the update pass skips released records
         bvh.released = true;
 
-        this.#slot_pool.release(bvh.slot);
-        this.#map.delete(meshlets);
+        this.#map.delete(owner);
+
+        this.#release_topology_if_orphaned(bvh.topology);
 
         return true;
     }
 
+    /**
+     * Drop a shape once the last tree that had it is gone.
+     *
+     * The arena bytes are not reclaimed — same append-only story as the nodes — but the map entry
+     * holds a strong reference to the geometry it is keyed by, so leaving it would keep every
+     * geometry a scene ever loaded alive for as long as the manager is.
+     *
+     * @param {object} topology
+     */
+    #release_topology_if_orphaned(topology) {
+        for (const bvh of this.#map.values()) {
+            if (bvh.topology === topology) {
+                return;
+            }
+        }
+
+        for (const [source, candidate] of this.#topology) {
+            if (candidate === topology) {
+                this.#topology.delete(source);
+
+                return;
+            }
+        }
+    }
+
     /**
      *
      * @param {number} size
@@ -210,11 +424,11 @@ export class GPUGeometryBVHManager {
      *
      * @param {number} size
      */
-    #ensure_metadata_capacity(size) {
+    #ensure_metadata_capacity(row_count) {
         this.#buffer_metadata = ensure_buffer_capacity(
             this.#device,
             this.#buffer_metadata,
-            size * BLAS_METADATA_STRUCT.size,
+            Math.max(1, row_count) * BLAS_METADATA_STRUCT.size,
             BLAS_METADATA_STRUCT.align,
             16,
             1.2
@@ -222,26 +436,78 @@ export class GPUGeometryBVHManager {
     }
 
     /**
+     * Append every topology derived but not yet uploaded to its arena.
      *
-     * @param {GPUGeometryMeshletsBVH} element
-     * @param {DataView} target
-     * @param {number} target_offset byte offset inside the temp buffer; the temp buffer is
-     *        indexed by queue position, NOT by slot — slots are global and outrun the temp
-     *        buffer on any batch after the first
+     * Queue-free: the map is small (one entry per distinct geometry) and a `resident` flag says what
+     * is left to do, which is one fewer thing to keep in step than a second queue would be.
      */
-    #write_metadata_for(element, target, target_offset) {
+    #upload_pending_topology() {
+        const queue = this.#device.queue;
+
+        for (const topology of this.#topology.values()) {
+            if (topology.resident) {
+                continue;
+            }
+
+            const bytes = topology.source.bvh;
+
+            if (bytes === undefined || bytes.byteLength === 0) {
+                // no tree to take the shape of yet; try again next time
+                continue;
+            }
+
+            const { parents, leaf_nodes } = bvh2_derive_topology(bytes);
+
+            this.#buffer_parents = ensure_buffer_capacity(
+                this.#device,
+                this.#buffer_parents,
+                (this.#buffer_parents_end + parents.length) * Uint32Array.BYTES_PER_ELEMENT,
+                DATA_SIZE_ALIGNMENT,
+                DATA_GROWTH_STEP,
+                DATA_GROWTH_MULTIPLIER
+            );
 
-        target.setUint32(
-            target_offset,
-            element.address,
-            endianness
-        );
+            this.#buffer_leaf_nodes = ensure_buffer_capacity(
+                this.#device,
+                this.#buffer_leaf_nodes,
+                (this.#buffer_leaf_nodes_end + leaf_nodes.length) * Uint32Array.BYTES_PER_ELEMENT,
+                DATA_SIZE_ALIGNMENT,
+                DATA_GROWTH_STEP,
+                DATA_GROWTH_MULTIPLIER
+            );
 
-    }
+            topology.parents_offset = this.#buffer_parents_end;
+            topology.leaf_nodes_offset = this.#buffer_leaf_nodes_end;
 
+            queue.writeBuffer(
+                this.#buffer_parents,
+                topology.parents_offset * Uint32Array.BYTES_PER_ELEMENT,
+                parents, 0, parents.length
+            );
+
+            queue.writeBuffer(
+                this.#buffer_leaf_nodes,
+                topology.leaf_nodes_offset * Uint32Array.BYTES_PER_ELEMENT,
+                leaf_nodes, 0, leaf_nodes.length
+            );
+
+            this.#buffer_parents_end += parents.length;
+            this.#buffer_leaf_nodes_end += leaf_nodes.length;
+
+            topology.leaf_count = leaf_nodes.length;
+            // slots, not tree nodes — the arena numbers a tree's nodes with the free list's holes
+            // in, and a refit's arrival counters are indexed by that numbering
+            topology.node_count = parents.length;
+            topology.resident = true;
+        }
+    }
 
     update() {
 
+        // Ahead of the early return below: topology residency is its own question, and leaving it
+        // behind a queue of node uploads would make it depend on there happening to be one.
+        this.#upload_pending_topology();
+
         const queue = this.#update_queue;
 
         const queue_size = queue.size();
@@ -275,7 +541,6 @@ export class GPUGeometryBVHManager {
             used_node_count += node_count;
         }
 
-        this.#ensure_metadata_capacity(this.#map.size);
         this.#ensure_data_capacity(this.#node_capacity + used_node_count);
 
 
@@ -321,6 +586,7 @@ export class GPUGeometryBVHManager {
             const address = this.#buffer_data_end;
 
             blas.address = address / BVH2_NODE_STRUCT.size;
+            blas.resident = true;
 
             const blas_size = blas.bvh.byteLength;
 
@@ -338,51 +604,10 @@ export class GPUGeometryBVHManager {
 
         console.warn(`BLAS size: ${number_format_by_thousands(this.#buffer_data_end)} bytes`);
 
-        // write metadata
-        const temp_metadata_buffer = device.createBuffer({
-            label: "temp_metadata_buffer",
-            usage: GPUBufferUsage.COPY_SRC,
-            size: queue_size * BLAS_METADATA_STRUCT.size,
-            mappedAtCreation: true
-        });
-
-        const mapped_temp_metadata = temp_metadata_buffer.getMappedRange();
-
-        const mapped_temp_metadata_view = new DataView(mapped_temp_metadata);
-
-        // write metadata
-        for (let i = 0; i < queue_size; i++) {
-            const blas = queue.getElementByIndex(i);
-
-            if (blas.released) { continue; }
-
-            this.#write_metadata_for(blas, mapped_temp_metadata_view, i * BLAS_METADATA_STRUCT.size);
-        }
-
-        // unmap before encoding anything that reads the buffer: a command naming a mapped buffer is
-        // a validation error, and the copies below would be dropped. Same shape as the data buffer
-        // above, which already writes, unmaps, and only then copies
-        temp_metadata_buffer.unmap();
-
-        // copy metadata from temp buffer to where it needs to go
-
-        for (let i = 0; i < queue_size; i++) {
-            const blas = queue.getElementByIndex(i);
-
-            if (blas.released) { continue; }
-
-            encoder.copyBufferToBuffer(
-                temp_metadata_buffer, i * BLAS_METADATA_STRUCT.size,
-                this.#buffer_metadata, blas.slot * BLAS_METADATA_STRUCT.size,
-                BLAS_METADATA_STRUCT.size
-            );
-        }
-
         device.queue.submit([encoder.finish()])
 
         // free up the temp buffer
         temp_data_buffer.destroy();
-        temp_metadata_buffer.destroy();
 
         // drain: everything queued is now resident. Leaving entries in the queue re-uploads
         // every BLAS ever registered on each update and appends fresh copies at

package/src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.d.ts

@@ -4,19 +4,31 @@ export class GPUGeometryMeshletsBVH {
      */
     bvh: ArrayBuffer;
     /**
-     * Integer metadata slot that this geometry occupies
+     * Node index this tree's root sits at within the manager's arena. Not a byte offset — the
+     * traversal shaders index `blas_data` by node.
+     *
      * @type {number}
      */
-    slot: number;
+    address: number;
     /**
-     * Where in the GPU BLAS memory this tree lives at
-     * @type {number}
+     * The shape of this tree — parents and leaf positions — shared with every other copy of the same
+     * geometry, because a copy differs only in where its bounds are.
+     *
+     * @type {object}
      */
-    address: number;
+    topology: object;
+    /**
+     * Whether {@link address} means anything yet. A record is registered before its nodes are
+     * resident, and an address of 0 is a perfectly good arena position, so "not yet uploaded"
+     * needs saying rather than encoding.
+     *
+     * @type {boolean}
+     */
+    resident: boolean;
     /**
      * Set when the geometry has been removed. A record can still sit in the manager's update
      * queue when it is removed in the same frame it was registered; the update pass skips
-     * released records so it never writes to a recycled slot.
+     * released records.
      * @type {boolean}
      */
     released: boolean;

package/src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryMeshletsBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.js"],"names":[],"mappings":"AAAA;IAEI;;OAEG;IACH,KAFU,WAAW,CAEjB;IAEJ;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,UAFU,OAAO,CAEA;CACpB"}
+{"version":3,"file":"GPUGeometryMeshletsBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.js"],"names":[],"mappings":"AAAA;IAEI;;OAEG;IACH,KAFU,WAAW,CAEjB;IAEJ;;;;;OAKG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,UAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;CACpB"}

package/src/shade/renderer/geometry/bvh/GPUGeometryMeshletsBVH.js

@@ -6,21 +6,34 @@ export class GPUGeometryMeshletsBVH {
     bvh;
 
     /**
-     * Integer metadata slot that this geometry occupies
+     * Node index this tree's root sits at within the manager's arena. Not a byte offset — the
+     * traversal shaders index `blas_data` by node.
+     *
      * @type {number}
      */
-    slot = 0;
+    address = 0;
 
     /**
-     * Where in the GPU BLAS memory this tree lives at
-     * @type {number}
+     * The shape of this tree — parents and leaf positions — shared with every other copy of the same
+     * geometry, because a copy differs only in where its bounds are.
+     *
+     * @type {object}
      */
-    address = 0;
+    topology;
+
+    /**
+     * Whether {@link address} means anything yet. A record is registered before its nodes are
+     * resident, and an address of 0 is a perfectly good arena position, so "not yet uploaded"
+     * needs saying rather than encoding.
+     *
+     * @type {boolean}
+     */
+    resident = false;
 
     /**
      * Set when the geometry has been removed. A record can still sit in the manager's update
      * queue when it is removed in the same frame it was registered; the update pass skips
-     * released records so it never writes to a recycled slot.
+     * released records.
      * @type {boolean}
      */
     released = false;

package/src/shade/renderer/geometry/bvh/bvh2_check_bounds.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Does every node's box contain its children's, walking from the root?
+ *
+ * Containment rather than equality, because the two are different claims and only one of them is
+ * required for correctness. A refit that computes each node as the exact union of its children
+ * satisfies both; a builder that inflates boxes, or a refit that ran a frame before the leaves under
+ * it moved inward, satisfies containment alone and is still a tree rays can traverse. Equality is
+ * available as `tight` for callers who want to assert the stronger thing.
+ *
+ * Walks the tree rather than scanning the buffer: the arena holds `node_capacity` slots and the
+ * builder allocates from a free list, so slots the tree never reaches hold whatever their last
+ * occupant left and are not anybody's problem.
+ *
+ * @param {ArrayBuffer|Float32Array} nodes the tree's node region
+ * @param {object} [options]
+ * @param {number} [options.slack] fraction of the box's own magnitude a child may overshoot by
+ * @returns {{problems: string[], internal: number, leaves: number, tight: boolean}}
+ */
+export function bvh2_check_containment(nodes: ArrayBuffer | Float32Array, { slack }?: {
+    slack?: number;
+}): {
+    problems: string[];
+    internal: number;
+    leaves: number;
+    tight: boolean;
+};
+/**
+ * Does every leaf's box contain the triangle that leaf names?
+ *
+ * `triangle_bounds` is asked for the AABB of the three vertices behind a leaf's payload — the same
+ * payload the ray query decodes, so a caller supplies whatever reads vertices in its world and this
+ * stays out of the meshlet layout entirely.
+ *
+ * Returning `null` means "no triangle for this payload", which is itself a failure: a leaf naming a
+ * triangle nobody can find is a leaf a ray descends into for nothing.
+ *
+ * @param {ArrayBuffer|Float32Array} nodes
+ * @param {function(number, number): (number[]|null)} triangle_bounds `(payload, leaf_node)` to
+ * `[min.xyz, max.xyz]`
+ * @param {object} [options]
+ * @param {number} [options.slack]
+ * @returns {{problems: string[], leaves: number, tight: boolean}}
+ */
+export function bvh2_check_leaf_bounds(nodes: ArrayBuffer | Float32Array, triangle_bounds: (arg0: number, arg1: number) => (number[] | null), { slack }?: {
+    slack?: number;
+}): {
+    problems: string[];
+    leaves: number;
+    tight: boolean;
+};
+//# sourceMappingURL=bvh2_check_bounds.d.ts.map

package/src/shade/renderer/geometry/bvh/bvh2_check_bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh2_check_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_check_bounds.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;GAiBG;AACH,8CALW,WAAW,GAAC,YAAY;IAEP,KAAK,GAAtB,MAAM;;cACO,MAAM,EAAE;cAAY,MAAM;YAAU,MAAM;WAAS,OAAO;EAwFjF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CAPW,WAAW,GAAC,YAAY,0BACf,MAAM,QAAE,MAAM,KAAG,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC;IAGxB,KAAK,GAAtB,MAAM;;cACO,MAAM,EAAE;YAAU,MAAM;WAAS,OAAO;EA6D/D"}