@woosh/meep-engine 3.69.0 → 3.70.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.69.0",
+  "version": "3.70.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/bvh8/build/BVH8Converter.d.ts

@@ -17,6 +17,22 @@ export class BVH8Converter {
      * @type {BVH8}
      */
     bvh8: BVH8;
+    /**
+     * Marks the BVH2 nodes that are roots of a primitive cluster, one byte per BVH2 node, non-zero for a
+     * root; `null` for a tree with no clusters.
+     *
+     * A cluster root always becomes a BVH8 node of its own, and no leaf slot is formed out of a BVH2
+     * node that holds a cluster root beneath it. Together those two give the guarantee this exists for:
+     * every BVH8 node's leaf slots draw their primitives from one cluster, and the run of
+     * {@link BVH8#primitives} a cluster's nodes address is contiguous and holds that cluster's primitives
+     * and nothing else. A consumer whose primitives are stored per cluster can then re-order each
+     * cluster's own storage to match and drop the pool.
+     *
+     * Cluster subtrees must be disjoint.
+     *
+     * @type {Uint8Array|null}
+     */
+    cluster_roots: Uint8Array | null;
     /**
      * Fill the decision table for the subtree of the given node, bottom-up.
      * @param {number} node_index

package/src/core/bvh8/build/BVH8Converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH8Converter.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/BVH8Converter.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH;IAYI;;;;OAIG;IACH,mCAGC;IAnBD;;;OAGG;IACH,UAAI;IAEJ;;OAEG;IACH,WAAI;IAkBJ;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAgJlB;IAED;;;;;;;;OAQG;IACH,yBANW,MAAM,YACN,MAAM,EAAE,GAAC,WAAW,gBACpB,MAAM,KACN,MAAM,GACJ,MAAM,CAoDlB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,YACN,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,QAkFhB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAiClB;IAED;;;;OAIG;IACH,0BAHW,MAAM,mBACN,MAAM,QAYhB;IAoJD,gBAoBC;;CACJ"}
+{"version":3,"file":"BVH8Converter.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/BVH8Converter.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH;IA6BI;;;;OAIG;IACH,mCAGC;IApCD;;;OAGG;IACH,UAAI;IAEJ;;OAEG;IACH,WAAI;IAEJ;;;;;;;;;;;;;;OAcG;IACH,eAFU,UAAU,GAAC,IAAI,CAEL;IAkBpB;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAmLlB;IAED;;;;;;;;OAQG;IACH,yBANW,MAAM,YACN,MAAM,EAAE,GAAC,WAAW,gBACpB,MAAM,KACN,MAAM,GACJ,MAAM,CAoDlB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,YACN,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,QAoDhB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAiClB;IAED;;;;OAIG;IACH,0BAHW,MAAM,mBACN,MAAM,QAYhB;IAwJD,gBAoBC;;CACJ"}

package/src/core/bvh8/build/BVH8Converter.js

@@ -3,6 +3,7 @@ import { reinterpret_float32_as_uint32 } from "../../binary/reinterpret_float32_
 import { NULL_NODE } from "../../bvh2/bvh3/BVH.js";
 import { BinaryElementPool } from "../../geom/3d/topology/struct/binary/BinaryElementPool.js";
 import { v3_dot } from "../../geom/vec3/v3_dot.js";
+import { bvh8_assign_slots_greedy } from "./bvh8_assign_slots_greedy.js";
 import { byte } from "./byte.js";
 import { encode_bounds_e } from "./encode_bounds_e.js";
 
@@ -48,6 +49,23 @@ export class BVH8Converter {
      */
     bvh8
 
+    /**
+     * Marks the BVH2 nodes that are roots of a primitive cluster, one byte per BVH2 node, non-zero for a
+     * root; `null` for a tree with no clusters.
+     *
+     * A cluster root always becomes a BVH8 node of its own, and no leaf slot is formed out of a BVH2
+     * node that holds a cluster root beneath it. Together those two give the guarantee this exists for:
+     * every BVH8 node's leaf slots draw their primitives from one cluster, and the run of
+     * {@link BVH8#primitives} a cluster's nodes address is contiguous and holds that cluster's primitives
+     * and nothing else. A consumer whose primitives are stored per cluster can then re-order each
+     * cluster's own storage to match and drop the pool.
+     *
+     * Cluster subtrees must be disjoint.
+     *
+     * @type {Uint8Array|null}
+     */
+    cluster_roots = null
+
     /**
      *
      * @param {BVH8} bvh8
@@ -90,22 +108,33 @@ export class BVH8Converter {
 
         const primitive_counts = new Uint32Array(bvh2.size);
 
+        const cluster_roots = this.cluster_roots;
+
+        // non-zero where a node holds a cluster root strictly beneath it
+        const spans_clusters = new Uint8Array(cluster_roots !== null ? bvh2.size : 0);
+
         for (let k = order.length - 1; k >= 0; k--) {
             const node = order[k];
 
             const node_surface_area = bvh2.node_get_surface_area(node);
 
+            const is_cluster_root = cluster_roots !== null && cluster_roots[node] !== 0;
+
             if (bvh2.node_is_leaf(node)) {
                 const num_primitives = 1;
 
-                // SAH cost
-                const cost_leaf = node_surface_area * num_primitives;
+                // SAH cost; a cluster of one primitive is a node holding one leaf slot
+                const cost = is_cluster_root
+                    ? node_surface_area * (num_primitives + 1)
+                    : node_surface_area * num_primitives;
+
+                const type = is_cluster_root ? DECISION_TYPE.INTERNAL : DECISION_TYPE.LEAF;
 
                 for (let i = 0; i < 7; i++) {
                     const decision_ptr = decisions.element_address(node * 7 + i);
 
-                    decisions.data_view.setUint8(decision_ptr, DECISION_TYPE.LEAF);
-                    decisions.data_view.setFloat32(decision_ptr + DECISION_OFFSET_COST, cost_leaf);
+                    decisions.data_view.setUint8(decision_ptr, type);
+                    decisions.data_view.setFloat32(decision_ptr + DECISION_OFFSET_COST, cost);
                 }
 
                 primitive_counts[node] = num_primitives;
@@ -116,10 +145,21 @@ export class BVH8Converter {
 
                 const num_primitives = primitive_counts[left] + primitive_counts[right];
 
+                let can_be_leaf = num_primitives <= 3;
+
+                if (cluster_roots !== null) {
+                    const spans = (cluster_roots[left] | cluster_roots[right] | spans_clusters[left] | spans_clusters[right]) !== 0;
+
+                    spans_clusters[node] = spans ? 1 : 0;
+
+                    // a leaf slot holds one cluster's primitives, and a cluster root is a node
+                    can_be_leaf = can_be_leaf && !spans && !is_cluster_root;
+                }
+
                 // Separate case: i=0 (i=1 in the paper)
                 // create a new subtree root
                 {
-                    const cost_leaf = num_primitives <= 3 ? num_primitives * node_surface_area : Infinity;
+                    const cost_leaf = can_be_leaf ? num_primitives * node_surface_area : Infinity;
 
                     let cost_distribute = Infinity;
 
@@ -164,6 +204,19 @@ export class BVH8Converter {
                 for (let i = 1; i < 7; i++) {
                     const decision_ptr_i = decisions.element_address(node * 7 + i - 1);
 
+                    if (is_cluster_root) {
+                        // a cluster root is one root, however many its parent could afford
+                        const decision_ptr = decisions.element_address(node * 7 + i);
+
+                        for (let j = 0; j < 7; j++) {
+                            decisions.data_view.setUint8(decision_ptr + j,
+                                decisions.data_view.getUint8(decision_ptr_i + j)
+                            );
+                        }
+
+                        continue;
+                    }
+
                     let cost_distribute = decisions.data_view.getFloat32(decision_ptr_i + DECISION_OFFSET_COST);
 
                     let distribute_left = INVALID;
@@ -315,38 +368,8 @@ export class BVH8Converter {
         }
 
         const assignment = new Uint32Array(8);
-        assignment.fill(INVALID);
-
-        let slot_filled = 0; // bitfield
-
-
-        // Greedy child ordering, the paper mentions this as an alternative
-        // that works about as well as the auction algorithm in practice
-        while (true) {
-            let min_cost = Infinity;
 
-            let min_slot = INVALID;
-            let min_index = INVALID;
-
-            // Find the cheapest unfilled slot of any unassigned child
-            for (let c = 0; c < child_count; c++) {
-                if (assignment[c] === INVALID) {
-                    for (let s = 0; s < 8; s++) {
-                        if ((slot_filled & (1 << s)) === 0 && cost[c * 8 + s] < min_cost) {
-                            min_cost = cost[c * 8 + s];
-
-                            min_slot = s;
-                            min_index = c;
-                        }
-                    }
-                }
-            }
-
-            if (min_slot === INVALID) break;
-
-            slot_filled |= 1 << min_slot;
-            assignment [min_index] = min_slot;
-        }
+        bvh8_assign_slots_greedy(assignment, cost, child_count);
 
         // Permute children array according to assignment
         const children_copy = new Uint32Array(8);
@@ -507,7 +530,11 @@ export class BVH8Converter {
 
             const child_decision_ptr = this.#decisions.element_address(child_index * 7);
 
-            const child_decision_type = this.#decisions.data_view.getUint8(child_decision_ptr);
+            // a BVH2 leaf asked for its children answers with itself: a cluster of one primitive, or a
+            // tree of one, and either way this node's one slot is that primitive
+            const child_decision_type = child_index === node_index_bvh2
+                ? DECISION_TYPE.LEAF
+                : this.#decisions.data_view.getUint8(child_decision_ptr);
 
             let child_meta = 0;
 

package/src/core/bvh8/build/bvh8_assign_slots_greedy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Give each child of a wide node one of its eight slots, cheapest pair first.
+ *
+ * A ray visits a node's slots in an order fixed by the signs of its direction, so which slot a child
+ * sits in decides how early a ray going its way reaches it. `cost[child * 8 + slot]` says how badly a
+ * child suits a slot; the cheapest (child, slot) pair still open is taken until every child has a
+ * slot. Ylitie et al. name this greedy as doing about as well in practice as the auction algorithm
+ * they use.
+ *
+ * Of equal costs the first met wins: children in order, and for a child its slots in order. Two
+ * builders that fill the table with the same numbers get the same slots.
+ *
+ * @param {Uint32Array|number[]} assignment output, a slot per child; {@link BVH8_SLOT_UNASSIGNED}
+ * past `child_count`
+ * @param {Float32Array|number[]} cost 64 entries, `[child * 8 + slot]`; read for `child < child_count`
+ * @param {number} child_count at most 8
+ * @returns {number} the slots taken, a bit each
+ */
+export function bvh8_assign_slots_greedy(assignment: Uint32Array | number[], cost: Float32Array | number[], child_count: number): number;
+/**
+ * What {@link bvh8_assign_slots_greedy} leaves in `assignment` for a child it was not asked about.
+ * @type {number}
+ */
+export const BVH8_SLOT_UNASSIGNED: number;
+//# sourceMappingURL=bvh8_assign_slots_greedy.d.ts.map

package/src/core/bvh8/build/bvh8_assign_slots_greedy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_assign_slots_greedy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/bvh8_assign_slots_greedy.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDANW,WAAW,GAAC,MAAM,EAAE,QAEpB,YAAY,GAAC,MAAM,EAAE,eACrB,MAAM,GACJ,MAAM,CA2ClB;AAjED;;;GAGG;AACH,mCAFU,MAAM,CAE+B"}

package/src/core/bvh8/build/bvh8_assign_slots_greedy.js

@@ -0,0 +1,68 @@
+import { assert } from "../../assert.js";
+
+/**
+ * What {@link bvh8_assign_slots_greedy} leaves in `assignment` for a child it was not asked about.
+ * @type {number}
+ */
+export const BVH8_SLOT_UNASSIGNED = 0xFFFFFFFF;
+
+/**
+ * Give each child of a wide node one of its eight slots, cheapest pair first.
+ *
+ * A ray visits a node's slots in an order fixed by the signs of its direction, so which slot a child
+ * sits in decides how early a ray going its way reaches it. `cost[child * 8 + slot]` says how badly a
+ * child suits a slot; the cheapest (child, slot) pair still open is taken until every child has a
+ * slot. Ylitie et al. name this greedy as doing about as well in practice as the auction algorithm
+ * they use.
+ *
+ * Of equal costs the first met wins: children in order, and for a child its slots in order. Two
+ * builders that fill the table with the same numbers get the same slots.
+ *
+ * @param {Uint32Array|number[]} assignment output, a slot per child; {@link BVH8_SLOT_UNASSIGNED}
+ * past `child_count`
+ * @param {Float32Array|number[]} cost 64 entries, `[child * 8 + slot]`; read for `child < child_count`
+ * @param {number} child_count at most 8
+ * @returns {number} the slots taken, a bit each
+ */
+export function bvh8_assign_slots_greedy(assignment, cost, child_count) {
+    assert.isNonNegativeInteger(child_count, 'child_count');
+    assert.lessThanOrEqual(child_count, 8, 'a node has eight slots');
+
+    for (let i = 0; i < 8; i++) {
+        assignment[i] = BVH8_SLOT_UNASSIGNED;
+    }
+
+    let slot_filled = 0;
+
+    for (; ;) {
+        let min_cost = Infinity;
+
+        let min_slot = BVH8_SLOT_UNASSIGNED;
+        let min_index = BVH8_SLOT_UNASSIGNED;
+
+        // the cheapest open slot of any child still without one
+        for (let c = 0; c < child_count; c++) {
+            if (assignment[c] !== BVH8_SLOT_UNASSIGNED) {
+                continue;
+            }
+
+            for (let s = 0; s < 8; s++) {
+                if ((slot_filled & (1 << s)) === 0 && cost[c * 8 + s] < min_cost) {
+                    min_cost = cost[c * 8 + s];
+
+                    min_slot = s;
+                    min_index = c;
+                }
+            }
+        }
+
+        if (min_slot === BVH8_SLOT_UNASSIGNED) {
+            break;
+        }
+
+        slot_filled |= 1 << min_slot;
+        assignment[min_index] = min_slot;
+    }
+
+    return slot_filled;
+}

package/src/core/bvh8/build/bvh8_from_proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh8_from_proxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/bvh8_from_proxy.js"],"names":[],"mappings":"AA0OA;;;;;;GAMG;AACH,0EAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QAgBlB"}
+{"version":3,"file":"bvh8_from_proxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/bvh8_from_proxy.js"],"names":[],"mappings":"AA2MA;;;;;;GAMG;AACH,0EAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QAgBlB"}

package/src/core/bvh8/build/bvh8_from_proxy.js

@@ -1,6 +1,7 @@
 import { assert } from "../../assert.js";
 import { reinterpret_float32_as_uint32 } from "../../binary/reinterpret_float32_as_uint32.js";
 import { v3_dot } from "../../geom/vec3/v3_dot.js";
+import { bvh8_assign_slots_greedy } from "./bvh8_assign_slots_greedy.js";
 import { byte } from "./byte.js";
 import { encode_bounds_e } from "./encode_bounds_e.js";
 
@@ -41,41 +42,9 @@ function bvh8_sort_children(node, children, child_count) {
         }
     }
 
-    const INVALID = 0xFFFFFFFF;
-
     const assignment = new Uint32Array(8);
-    assignment.fill(INVALID);
-
-    let slot_filled = 0; // bitfield
-
-
-    // Greedy child ordering, the paper mentions this as an alternative
-    // that works about as well as the auction algorithm in practice
-    while (true) {
-        let min_cost = Infinity;
-
-        let min_slot = INVALID;
-        let min_index = INVALID;
-
-        // Find the cheapest unfilled slot of any unassigned child
-        for (let c = 0; c < child_count; c++) {
-            if (assignment[c] === INVALID) {
-                for (let s = 0; s < 8; s++) {
-                    if ((slot_filled & (1 << s)) === 0 && cost[c * 8 + s] < min_cost) {
-                        min_cost = cost[c * 8 + s];
 
-                        min_slot = s;
-                        min_index = c;
-                    }
-                }
-            }
-        }
-
-        if (min_slot === INVALID) break;
-
-        slot_filled |= 1 << min_slot;
-        assignment [min_index] = min_slot;
-    }
+    bvh8_assign_slots_greedy(assignment, cost, child_count);
 
     // Permute children array according to assignment
     const children_copy = new Array(8);

package/src/core/bvh8/build/bvh8_node_fit_slots.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Put a node on the grid of its own box, and write each of its occupied slots' boxes in bytes on it:
+ * the origin at the box's low corner, a power-of-two step an axis that spans the box in 255, a
+ * slot's low corner rounded down to the grid and its high corner up.
+ *
+ * Writes the node's origin, its three exponents and the quantized boxes of the slots named, and
+ * zeroes the boxes of the others. The node's child mask, its bases and its metas are left as they
+ * are.
+ *
+ * Every step is a single-precision one, in a fixed order, and it is the arithmetic the GPU's passes
+ * that fit nodes do (`shader_blas8_refit_batch`, the TLAS encode): the same boxes in give the same
+ * words out, there and here. A slot's box comes out holding the box it was given whenever that box
+ * lies inside the node's.
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {ArrayLike<number>} box the node's own box, `[min.xyz, max.xyz]`, float32 values
+ * @param {ArrayLike<number>} slot_boxes six floats a slot, 48 in all; read for the slots in `occupied`
+ * @param {number} occupied the slots to write, a bit each
+ */
+export function bvh8_node_fit_slots(bvh: BVH8, node: number, box: ArrayLike<number>, slot_boxes: ArrayLike<number>, occupied: number): void;
+//# sourceMappingURL=bvh8_node_fit_slots.d.ts.map

package/src/core/bvh8/build/bvh8_node_fit_slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_node_fit_slots.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/bvh8_node_fit_slots.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qDALW,MAAM,OACN,UAAU,MAAM,CAAC,cACjB,UAAU,MAAM,CAAC,YACjB,MAAM,QA6ChB"}

package/src/core/bvh8/build/bvh8_node_fit_slots.js

@@ -0,0 +1,115 @@
+import { assert } from "../../assert.js";
+import { reinterpret_float32_as_uint32 } from "../../binary/reinterpret_float32_as_uint32.js";
+import { reinterpret_uint32_as_float32 } from "../../binary/reinterpret_uint32_as_float32.js";
+
+const fround = Math.fround;
+
+const ONE_OVER_255 = fround(1 / 255);
+
+/**
+ * The next float up from a difference that cannot be negative. A difference of two floats is
+ * rounded, and a box must not shrink by the rounding. Nothing is added to an exact zero.
+ *
+ * @param {number} x a float32 value, zero or above
+ * @returns {number}
+ */
+function round_up(x) {
+    return x > 0 ? reinterpret_uint32_as_float32(reinterpret_float32_as_uint32(x) + 1) : x;
+}
+
+/**
+ * The next float down, as {@link round_up} is the next up.
+ *
+ * @param {number} x a float32 value, zero or above
+ * @returns {number}
+ */
+function round_down(x) {
+    return x > 0 ? reinterpret_uint32_as_float32(reinterpret_float32_as_uint32(x) - 1) : x;
+}
+
+/**
+ * The exponent byte of the smallest power of two that spans an extent in 255 steps; zero, a step of
+ * nothing, for no extent at all.
+ *
+ * @param {number} extent a float32 value
+ * @returns {number}
+ */
+function step_exponent(extent) {
+    if (!(extent > 0)) {
+        return 0;
+    }
+
+    // the power of two at or below a 255th of the extent, and the next one up unless that one spans it
+    let exponent = (reinterpret_float32_as_uint32(fround(extent * ONE_OVER_255)) >>> 23) & 0xFF;
+
+    if (extent > fround(255 * reinterpret_uint32_as_float32(exponent << 23))) {
+        exponent += 1;
+    }
+
+    return exponent;
+}
+
+/**
+ * Put a node on the grid of its own box, and write each of its occupied slots' boxes in bytes on it:
+ * the origin at the box's low corner, a power-of-two step an axis that spans the box in 255, a
+ * slot's low corner rounded down to the grid and its high corner up.
+ *
+ * Writes the node's origin, its three exponents and the quantized boxes of the slots named, and
+ * zeroes the boxes of the others. The node's child mask, its bases and its metas are left as they
+ * are.
+ *
+ * Every step is a single-precision one, in a fixed order, and it is the arithmetic the GPU's passes
+ * that fit nodes do (`shader_blas8_refit_batch`, the TLAS encode): the same boxes in give the same
+ * words out, there and here. A slot's box comes out holding the box it was given whenever that box
+ * lies inside the node's.
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {ArrayLike<number>} box the node's own box, `[min.xyz, max.xyz]`, float32 values
+ * @param {ArrayLike<number>} slot_boxes six floats a slot, 48 in all; read for the slots in `occupied`
+ * @param {number} occupied the slots to write, a bit each
+ */
+export function bvh8_node_fit_slots(bvh, node, box, slot_boxes, occupied) {
+    assert.isNonNegativeInteger(node, 'node');
+    assert.isNonNegativeInteger(occupied, 'occupied');
+    assert.lessThan(occupied, 256, 'a node has eight slots');
+
+    const min_x = box[0], min_y = box[1], min_z = box[2];
+
+    const exponent_x = step_exponent(round_up(fround(box[3] - min_x)));
+    const exponent_y = step_exponent(round_up(fround(box[4] - min_y)));
+    const exponent_z = step_exponent(round_up(fround(box[5] - min_z)));
+
+    bvh.node_set_p(node, min_x, min_y, min_z);
+    bvh.node_set_e(node, exponent_x, exponent_y, exponent_z);
+
+    // a step of nothing takes every byte to zero
+    const per_cell_x = exponent_x > 0 ? fround(1 / reinterpret_uint32_as_float32(exponent_x << 23)) : 0;
+    const per_cell_y = exponent_y > 0 ? fround(1 / reinterpret_uint32_as_float32(exponent_y << 23)) : 0;
+    const per_cell_z = exponent_z > 0 ? fround(1 / reinterpret_uint32_as_float32(exponent_z << 23)) : 0;
+
+    for (let slot = 0; slot < 8; slot++) {
+        if ((occupied & (1 << slot)) === 0) {
+            bvh.node_set_quantized_min(node, slot, 0, 0, 0);
+            bvh.node_set_quantized_max(node, slot, 0, 0, 0);
+
+            continue;
+        }
+
+        const o = slot * 6;
+
+        bvh.node_set_quantized_min(
+            node, slot,
+            Math.floor(fround(round_down(fround(slot_boxes[o] - min_x)) * per_cell_x)),
+            Math.floor(fround(round_down(fround(slot_boxes[o + 1] - min_y)) * per_cell_y)),
+            Math.floor(fround(round_down(fround(slot_boxes[o + 2] - min_z)) * per_cell_z)),
+        );
+
+        bvh.node_set_quantized_max(
+            node, slot,
+            Math.min(255, Math.ceil(fround(round_up(fround(slot_boxes[o + 3] - min_x)) * per_cell_x))),
+            Math.min(255, Math.ceil(fround(round_up(fround(slot_boxes[o + 4] - min_y)) * per_cell_y))),
+            Math.min(255, Math.ceil(fround(round_up(fround(slot_boxes[o + 5] - min_z)) * per_cell_z))),
+        );
+    }
+}

package/src/core/bvh8/bvh8_depth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Levels of nodes in a BVH8, the root's included: 1 for a tree of one node, 0 for an empty one.
+ *
+ * @param {BVH8} bvh
+ * @returns {number}
+ */
+export function bvh8_depth(bvh: BVH8): number;
+//# sourceMappingURL=bvh8_depth.d.ts.map

package/src/core/bvh8/bvh8_depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_depth.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_depth.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,uCAFa,MAAM,CAkClB"}

package/src/core/bvh8/bvh8_depth.js

@@ -0,0 +1,39 @@
+/**
+ * Levels of nodes in a BVH8, the root's included: 1 for a tree of one node, 0 for an empty one.
+ *
+ * @param {BVH8} bvh
+ * @returns {number}
+ */
+export function bvh8_depth(bvh) {
+    if (bvh.nodes.size === 0) {
+        return 0;
+    }
+
+    let deepest = 0;
+
+    // (node, level) pairs
+    const stack = [0, 1];
+
+    while (stack.length > 0) {
+        const level = stack.pop();
+        const node = stack.pop();
+
+        if (level > deepest) {
+            deepest = level;
+        }
+
+        const imask = bvh.node_get_imask(node);
+        const base_index_child = bvh.node_get_base_index_child(node);
+
+        let child = 0;
+
+        for (let slot = 0; slot < 8; slot++) {
+            if ((imask & (1 << slot)) !== 0) {
+                stack.push(base_index_child + child, level + 1);
+                child++;
+            }
+        }
+    }
+
+    return deepest;
+}

package/src/core/math/complex/complex_fft_radix2.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The discrete Fourier transform of `n` complex values, in place, radix 2:
+ *
+ *     X_k = Σ_j x_j · e^(∓2πi·jk/n)
+ *
+ * the minus sign forward, the plus sign inverse. The inverse is not scaled: a forward transform
+ * then an inverse one multiplies every value by `n`.
+ *
+ * Iterative Cooley–Tukey, decimation in time: a bit-reversal permutation, then `log2(n)` stages of
+ * butterflies. Each stage's twiddles are taken from `Math.cos` and `Math.sin` directly, `n − 1` pairs
+ * over the transform, so the error does not grow along a recurrence. Allocates nothing.
+ *
+ * @param {Float64Array|Float32Array|number[]} re real parts, read and written at `0..n−1`
+ * @param {Float64Array|Float32Array|number[]} im imaginary parts, likewise
+ * @param {number} n a power of two
+ * @param {boolean} inverse
+ */
+export function complex_fft_radix2(re: Float64Array | Float32Array | number[], im: Float64Array | Float32Array | number[], n: number, inverse: boolean): void;
+//# sourceMappingURL=complex_fft_radix2.d.ts.map

package/src/core/math/complex/complex_fft_radix2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complex_fft_radix2.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_fft_radix2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,uCALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,MAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,WACN,OAAO,QAoDjB"}

package/src/core/math/complex/complex_fft_radix2.js

@@ -0,0 +1,71 @@
+import { assert } from "../../assert.js";
+import { isPowerOfTwo } from "../isPowerOfTwo.js";
+
+/**
+ * The discrete Fourier transform of `n` complex values, in place, radix 2:
+ *
+ *     X_k = Σ_j x_j · e^(∓2πi·jk/n)
+ *
+ * the minus sign forward, the plus sign inverse. The inverse is not scaled: a forward transform
+ * then an inverse one multiplies every value by `n`.
+ *
+ * Iterative Cooley–Tukey, decimation in time: a bit-reversal permutation, then `log2(n)` stages of
+ * butterflies. Each stage's twiddles are taken from `Math.cos` and `Math.sin` directly, `n − 1` pairs
+ * over the transform, so the error does not grow along a recurrence. Allocates nothing.
+ *
+ * @param {Float64Array|Float32Array|number[]} re real parts, read and written at `0..n−1`
+ * @param {Float64Array|Float32Array|number[]} im imaginary parts, likewise
+ * @param {number} n a power of two
+ * @param {boolean} inverse
+ */
+export function complex_fft_radix2(re, im, n, inverse) {
+    assert.isPositiveInteger(n, 'n');
+    assert.ok(isPowerOfTwo(n), 'n is a power of two');
+
+    // bit-reversal permutation
+    for (let i = 1, j = 0; i < n; i++) {
+        let bit = n >> 1;
+
+        while ((j & bit) !== 0) {
+            j ^= bit;
+            bit >>= 1;
+        }
+
+        j ^= bit;
+
+        if (i < j) {
+            const r = re[i];
+            re[i] = re[j];
+            re[j] = r;
+
+            const m = im[i];
+            im[i] = im[j];
+            im[j] = m;
+        }
+    }
+
+    const sign = inverse ? 1 : -1;
+
+    for (let length = 2; length <= n; length <<= 1) {
+        const half = length >> 1;
+        const step = sign * 2 * Math.PI / length;
+
+        for (let k = 0; k < half; k++) {
+            const w_re = Math.cos(step * k);
+            const w_im = Math.sin(step * k);
+
+            for (let start = 0; start < n; start += length) {
+                const a = start + k;
+                const b = a + half;
+
+                const t_re = re[b] * w_re - im[b] * w_im;
+                const t_im = re[b] * w_im + im[b] * w_re;
+
+                re[b] = re[a] - t_re;
+                im[b] = im[a] - t_im;
+                re[a] += t_re;
+                im[a] += t_im;
+            }
+        }
+    }
+}