@woosh/meep-engine 2.156.0 → 2.157.0

package/src/core/bvh8/bvh8_convert_to_dot.js

@@ -0,0 +1,133 @@
+import { int32_to_binary_string } from "../binary/int32_to_binary_string.js";
+import LineBuilder from "../codegen/LineBuilder.js";
+import { bvh8_node_count_triangles } from "./bvh8_node_count_triangles.js";
+
+/**
+ *
+ * @param {number} index
+ * @return {string}
+ */
+function node_id(index) {
+    return `N_${index}`;
+}
+
+/**
+ *
+ * @param {Object} attributes
+ * @return {string}
+ */
+function attributes_to_dot(attributes) {
+    const key_names = Object.keys(attributes);
+
+    return key_names.map(key => {
+
+        return `${key}=${attributes[key]}`;
+
+    }).join(', ');
+}
+
+function build_node_label(bvh, root) {
+    const attribute_p = [];
+
+    bvh.node_get_p(root, attribute_p);
+    const imask = bvh.node_get_imask(root);
+
+    const pieces = [];
+    pieces.push(`<B>Node ${root}</B>`);
+
+    pieces.push(`imask = ${int32_to_binary_string(imask, "", 8)}`);
+    pieces.push(`p = (${attribute_p[0].toFixed(2)}, ${attribute_p[1].toFixed(2)}, ${attribute_p[2].toFixed(2)})`)
+    pieces.push(`base_index_child = ${bvh.node_get_base_index_child(root)}`)
+    pieces.push(`base_index_triangle = ${bvh.node_get_base_index_triangle(root)}`)
+    pieces.push(`meta = ${new Array(8).fill(0).map((_, i) => int32_to_binary_string(bvh.node_get_meta(root, i), "", 8)).join(" ")}`);
+
+    // count triangles
+    pieces.push(`primitive count = ${bvh8_node_count_triangles(bvh, root)}`);
+
+    return `<{ {${pieces.join('<BR/>')} } }>`
+}
+
+/**
+ *
+ * @param {LineBuilder} out
+ * @param {BVH8} bvh
+ * @param {number} root
+ */
+function parse_tree_nodes(out, bvh, root) {
+
+    const attribute_p = [];
+
+    bvh.node_get_p(root, attribute_p);
+
+    const base_index_child = bvh.node_get_base_index_child(root);
+
+    // attributes
+    const attributes = {
+        label: build_node_label(bvh, root),
+        style: "\"rounded,filled\"",
+    };
+
+    out.add(`${node_id(root)} [${attributes_to_dot(attributes)}]`);
+
+    let used_intermediate_slots = 0;
+    for (let i = 0; i < 8; i++) {
+
+        const child_meta = bvh.node_get_meta(root, i);
+
+        if (child_meta === 0) {
+            // empty slot
+            continue;
+        }
+
+        const meta_high = (child_meta >> 5) & 0b111;
+        const meta_low = (child_meta) & 0b11111;
+
+        if (meta_low < 24) {
+            // triangle group
+        } else {
+
+            // intermediate node
+            const child_node = used_intermediate_slots + base_index_child;
+            parse_tree_nodes(out, bvh, child_node);
+
+            used_intermediate_slots++;
+
+            out.add(`${node_id(root)} -> ${node_id(child_node)} [label="child ${i}"];`);
+        }
+
+    }
+}
+
+/**
+ * Generate Graphviz dot notation for BVH8 structure
+ * @see https://en.wikipedia.org/wiki/Graphviz
+ * @see https://graphviz.org/
+ * @see https://dreampuf.github.io/GraphvizOnline
+ * @param {BVH8} bvh
+ * @param {number} [root]
+ * @returns {string}
+ */
+export function bvh8_convert_to_dot(bvh, root = 0) {
+
+    const font = {
+        name: "helvetica",
+        size: 10
+    };
+
+    const lb = new LineBuilder();
+
+    lb.add('digraph BVH8 {');
+    lb.indent();
+    lb.add("graph [style=invis, rankdir=\"TB\" ordering=out, splines=spline]");
+    lb.add(`node [shape=record, fontname=\"${font.name}\", fontsize=${font.size}, margin=\"0.2,0.03\", fillcolor=ivory]`);
+
+
+    // output nodes
+    parse_tree_nodes(lb, bvh, root);
+
+    lb.dedent();
+    lb.add('}');
+
+
+    return lb.build();
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Count triangles referenced by the subtree rooted at the given node.
+ * @param {BVH8} bvh
+ * @param {number} root
+ * @returns {number}
+ */
+export function bvh8_count_primitives(bvh: BVH8, root: number): number;
+/**
+ * Collect triangle indices referenced by node metas, in depth-first slot order.
+ *
+ * Note on addressing conventions (see {@link BVH8} class documentation): for trees built by
+ * `bvh8_build_for_geometry` the output values are geometry triangle indices (direct); for
+ * {@link BVH8Converter}-built trees they are indices into {@link BVH8#primitives} (indirect).
+ *
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @returns {number} number of indices added to the output
+ */
+export function bvh8_collect_primitives(out: number[], out_offset: number, bvh: BVH8, node: number): number;
+//# sourceMappingURL=bvh8_count_primitives.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_count_primitives.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_count_primitives.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,uDAHW,MAAM,GACJ,MAAM,CA2BlB;AAED;;;;;;;;;;;;GAYG;AACH,6CANW,MAAM,EAAE,cACR,MAAM,mBAEN,MAAM,GACJ,MAAM,CAkDlB"}

package/src/core/bvh8/bvh8_count_primitives.js

@@ -0,0 +1,98 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+import { bvh8_node_count_triangles } from "./bvh8_node_count_triangles.js";
+
+/**
+ * Count triangles referenced by the subtree rooted at the given node.
+ * @param {BVH8} bvh
+ * @param {number} root
+ * @returns {number}
+ */
+export function bvh8_count_primitives(bvh, root) {
+    let result = 0;
+
+    const stack = [root];
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+
+        result += bvh8_node_count_triangles(bvh, node);
+
+        const imask = bvh.node_get_imask(node);
+        const base_index_child = bvh.node_get_base_index_child(node);
+
+        let intermediate_count = 0;
+
+        for (let i = 0; i < 8; i++) {
+            if ((imask & (1 << i)) !== 0) {
+                // internal node
+                stack.push(base_index_child + intermediate_count);
+                intermediate_count++;
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Collect triangle indices referenced by node metas, in depth-first slot order.
+ *
+ * Note on addressing conventions (see {@link BVH8} class documentation): for trees built by
+ * `bvh8_build_for_geometry` the output values are geometry triangle indices (direct); for
+ * {@link BVH8Converter}-built trees they are indices into {@link BVH8#primitives} (indirect).
+ *
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @returns {number} number of indices added to the output
+ */
+export function bvh8_collect_primitives(out, out_offset, bvh, node) {
+    let out_cursor = out_offset;
+
+    const stack = [node];
+
+    while (stack.length > 0) {
+        const current = stack.pop();
+
+        const imask = bvh.node_get_imask(current);
+
+        const base_index_child = bvh.node_get_base_index_child(current);
+        const base_index_triangle = bvh.node_get_base_index_triangle(current);
+
+        // process primitives
+        for (let i = 0; i < 8; i++) {
+            if ((imask & (1 << i)) !== 0) {
+                // internal slot, holds no triangles
+                continue;
+            }
+
+            const meta = bvh.node_get_meta(current, i);
+
+            let triangle_mask = (meta >> 5) & 0b111;
+            let triangle_offset = (meta & 0b11111);
+
+            while (triangle_mask !== 0) {
+
+                if ((triangle_mask & 0b1) !== 0) {
+                    out[out_cursor++] = base_index_triangle + triangle_offset;
+                    triangle_offset++;
+                }
+
+                triangle_mask = triangle_mask >>> 1;
+            }
+        }
+
+        // push intermediate children in reverse slot order, so they pop in ascending order,
+        // preserving depth-first output order
+        let intermediate_count = bitCount(imask);
+        for (let i = 7; i >= 0; i--) {
+            if ((imask & (1 << i)) !== 0) {
+                intermediate_count--;
+                stack.push(base_index_child + intermediate_count);
+            }
+        }
+    }
+
+    return out_cursor - out_offset;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Validate a BVH8 against the geometry it was built for.
+ *
+ * Expects the direct triangle addressing convention — `base_index_triangle` + meta offsets are
+ * geometry triangle indices, as produced by `bvh8_build_for_geometry`. For
+ * {@link BVH8Converter}-built trees, which address triangles through the {@link BVH8#primitives}
+ * pool, use `bvh8_geometry_validate_indirect` instead.
+ *
+ * Throws an Error on the first violation found.
+ *
+ * @param {BVH8} bvh
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function bvh8_geometry_validate(bvh: BVH8, index_array: number[], position_array: number[]): void;
+//# sourceMappingURL=bvh8_geometry_validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_geometry_validate.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate.js"],"names":[],"mappings":"AAuGA;;;;;;;;;;;;;GAaG;AACH,+DAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QAiClB"}

package/src/core/bvh8/bvh8_geometry_validate.js

@@ -0,0 +1,149 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+import { AABB3 } from "../geom/3d/aabb/AABB3.js";
+import { aabb3_from_v3_array } from "../geom/3d/aabb/aabb3_from_v3_array.js";
+import { number_compare_ascending } from "../primitives/numbers/number_compare_ascending.js";
+import { aabb3_from_triangle_by_index } from "./build/aabb3_from_triangle_by_index.js";
+import { bvh8_collect_primitives } from "./bvh8_count_primitives.js";
+import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
+
+/**
+ *
+ * @param {AABB3} aabb
+ */
+function aabb3_round_to_float32(aabb) {
+    aabb.x0 = Math.fround(aabb.x0);
+    aabb.y0 = Math.fround(aabb.y0);
+    aabb.z0 = Math.fround(aabb.z0);
+    aabb.x1 = Math.fround(aabb.x1);
+    aabb.y1 = Math.fround(aabb.y1);
+    aabb.z1 = Math.fround(aabb.z1);
+}
+
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {AABB3} root_bounds
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+function bvh8_geometry_validate_bounds(bvh, root_bounds, index_array, position_array) {
+    const child_aabb3 = new AABB3();
+    const triangle_aabb = new AABB3();
+
+    // (node index, bounds the node was reached through) pairs
+    const stack = [0, root_bounds];
+
+    while (stack.length > 0) {
+        const node_bounds = stack.pop();
+        const node = stack.pop();
+
+        const base_index_child = bvh.node_get_base_index_child(node);
+        const base_index_triangle = bvh.node_get_base_index_triangle(node);
+
+        const imask = bvh.node_get_imask(node);
+
+        // check triangles
+        for (let i = 0; i < 8; i++) {
+
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate node
+                continue;
+            }
+
+            const meta = bvh.node_get_meta(node, i);
+
+
+            if (meta === 0) {
+                // empty
+                continue;
+            }
+
+            const triangle_count = bitCount((meta >> 5) & 0b111);
+
+            const triangle_offset = (meta & 0b00011111);
+
+            bvh8_get_node_child_bounds(child_aabb3, 0, bvh, node, i);
+
+
+            for (let j = 0; j < triangle_count; j++) {
+                const triangle_index = triangle_offset + base_index_triangle + j;
+
+                aabb3_from_triangle_by_index(triangle_aabb, 0, triangle_index, index_array, position_array);
+
+                // the tree stores bounds at float32 precision; validate at the same precision
+                // (round-to-nearest is exactly what Float32Array storage did on every build path)
+                aabb3_round_to_float32(triangle_aabb);
+
+                if (!child_aabb3.containsBox(triangle_aabb)) {
+                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates child bounds`);
+                }
+
+                if (!node_bounds.containsBox(triangle_aabb)) {
+                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates parent bounds`);
+                }
+            }
+
+
+        }
+
+        // queue intermediate children
+        let intermediate_index = 0;
+        for (let i = 0; i < 8; i++) {
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate node
+                const child_bounds = new AABB3();
+                bvh8_get_node_child_bounds(child_bounds, 0, bvh, node, i);
+
+                stack.push(base_index_child + intermediate_index, child_bounds);
+                intermediate_index++;
+            }
+        }
+    }
+}
+
+/**
+ * Validate a BVH8 against the geometry it was built for.
+ *
+ * Expects the direct triangle addressing convention — `base_index_triangle` + meta offsets are
+ * geometry triangle indices, as produced by `bvh8_build_for_geometry`. For
+ * {@link BVH8Converter}-built trees, which address triangles through the {@link BVH8#primitives}
+ * pool, use `bvh8_geometry_validate_indirect` instead.
+ *
+ * Throws an Error on the first violation found.
+ *
+ * @param {BVH8} bvh
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function bvh8_geometry_validate(bvh, index_array, position_array) {
+    const triangle_count = index_array.length / 3;
+
+    if (bvh.nodes.size === 0) {
+        if (triangle_count !== 0) {
+            throw new Error(`BVH8 is empty, geometry has ${triangle_count} triangles`);
+        }
+
+        return;
+    }
+
+    const collected_indices = [];
+    const collected_index_count = bvh8_collect_primitives(collected_indices, 0, bvh, 0);
+
+    if (collected_index_count !== triangle_count) {
+        throw new Error(`BVH8 references ${collected_index_count} triangles, geometry has ${triangle_count}`);
+    }
+
+    collected_indices.sort(number_compare_ascending);
+    for (let i = 0; i < collected_index_count; i++) {
+        if (collected_indices[i] !== i) {
+            throw new Error(`Missing index ${i}`);
+        }
+    }
+
+    const geometry_bounds = new AABB3();
+    aabb3_from_v3_array(geometry_bounds, position_array, position_array.length);
+    aabb3_round_to_float32(geometry_bounds);
+
+    // check bounds
+    bvh8_geometry_validate_bounds(bvh, geometry_bounds, index_array, position_array);
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Validate a BVH8 against the geometry it was built for.
+ *
+ * Expects the indirect triangle addressing convention — `base_index_triangle` + meta offsets
+ * index into the {@link BVH8#primitives} pool, whose entries are geometry triangle indices, as
+ * produced by {@link BVH8Converter} from a BVH2 with one leaf per triangle and the triangle index
+ * as user data. For `bvh8_build_for_geometry`-built trees use `bvh8_geometry_validate` instead.
+ *
+ * Throws an Error on the first violation found.
+ *
+ * @param {BVH8} bvh
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function bvh8_geometry_validate_indirect(bvh: BVH8, index_array: number[], position_array: number[]): void;
+//# sourceMappingURL=bvh8_geometry_validate_indirect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_geometry_validate_indirect.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_geometry_validate_indirect.js"],"names":[],"mappings":"AA0GA;;;;;;;;;;;;;GAaG;AACH,wEAHW,MAAM,EAAE,kBACR,MAAM,EAAE,QA0DlB"}

package/src/core/bvh8/bvh8_geometry_validate_indirect.js

@@ -0,0 +1,177 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+import { AABB3 } from "../geom/3d/aabb/AABB3.js";
+import { aabb3_from_v3_array } from "../geom/3d/aabb/aabb3_from_v3_array.js";
+import { number_compare_ascending } from "../primitives/numbers/number_compare_ascending.js";
+import { aabb3_from_triangle_by_index } from "./build/aabb3_from_triangle_by_index.js";
+import { bvh8_collect_primitives } from "./bvh8_count_primitives.js";
+import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
+
+/**
+ *
+ * @param {AABB3} aabb
+ */
+function aabb3_round_to_float32(aabb) {
+    aabb.x0 = Math.fround(aabb.x0);
+    aabb.y0 = Math.fround(aabb.y0);
+    aabb.z0 = Math.fround(aabb.z0);
+    aabb.x1 = Math.fround(aabb.x1);
+    aabb.y1 = Math.fround(aabb.y1);
+    aabb.z1 = Math.fround(aabb.z1);
+}
+
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {AABB3} root_bounds
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+function bvh8_geometry_validate_bounds_indirect(bvh, root_bounds, index_array, position_array) {
+    const pool = bvh.primitives.data_uint32;
+
+    const child_aabb3 = new AABB3();
+    const triangle_aabb = new AABB3();
+
+    // (node index, bounds the node was reached through) pairs
+    const stack = [0, root_bounds];
+
+    while (stack.length > 0) {
+        const node_bounds = stack.pop();
+        const node = stack.pop();
+
+        const base_index_child = bvh.node_get_base_index_child(node);
+        const base_index_triangle = bvh.node_get_base_index_triangle(node);
+
+        const imask = bvh.node_get_imask(node);
+
+        // check triangles
+        for (let i = 0; i < 8; i++) {
+
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate node
+                continue;
+            }
+
+            const meta = bvh.node_get_meta(node, i);
+
+
+            if (meta === 0) {
+                // empty
+                continue;
+            }
+
+            const triangle_count = bitCount((meta >> 5) & 0b111);
+
+            const triangle_offset = (meta & 0b00011111);
+
+            bvh8_get_node_child_bounds(child_aabb3, 0, bvh, node, i);
+
+
+            for (let j = 0; j < triangle_count; j++) {
+                // resolve through the primitive pool
+                const triangle_index = pool[triangle_offset + base_index_triangle + j];
+
+                aabb3_from_triangle_by_index(triangle_aabb, 0, triangle_index, index_array, position_array);
+
+                // the tree stores bounds at float32 precision; validate at the same precision
+                // (round-to-nearest is exactly what Float32Array storage did on every build path)
+                aabb3_round_to_float32(triangle_aabb);
+
+                if (!child_aabb3.containsBox(triangle_aabb)) {
+                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates child bounds`);
+                }
+
+                if (!node_bounds.containsBox(triangle_aabb)) {
+                    throw new Error(`Triangle ${triangle_index} (node ${node}, slot ${i}) violates parent bounds`);
+                }
+            }
+
+
+        }
+
+        // queue intermediate children
+        let intermediate_index = 0;
+        for (let i = 0; i < 8; i++) {
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate node
+                const child_bounds = new AABB3();
+                bvh8_get_node_child_bounds(child_bounds, 0, bvh, node, i);
+
+                stack.push(base_index_child + intermediate_index, child_bounds);
+                intermediate_index++;
+            }
+        }
+    }
+}
+
+/**
+ * Validate a BVH8 against the geometry it was built for.
+ *
+ * Expects the indirect triangle addressing convention — `base_index_triangle` + meta offsets
+ * index into the {@link BVH8#primitives} pool, whose entries are geometry triangle indices, as
+ * produced by {@link BVH8Converter} from a BVH2 with one leaf per triangle and the triangle index
+ * as user data. For `bvh8_build_for_geometry`-built trees use `bvh8_geometry_validate` instead.
+ *
+ * Throws an Error on the first violation found.
+ *
+ * @param {BVH8} bvh
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function bvh8_geometry_validate_indirect(bvh, index_array, position_array) {
+    const triangle_count = index_array.length / 3;
+
+    if (bvh.nodes.size === 0) {
+        if (triangle_count !== 0) {
+            throw new Error(`BVH8 is empty, geometry has ${triangle_count} triangles`);
+        }
+
+        return;
+    }
+
+    const pool_size = bvh.primitives.size;
+
+    if (pool_size !== triangle_count) {
+        throw new Error(`primitive pool holds ${pool_size} entries, geometry has ${triangle_count} triangles`);
+    }
+
+    // metas must cover the pool exactly once
+    const collected_indices = [];
+    const collected_index_count = bvh8_collect_primitives(collected_indices, 0, bvh, 0);
+
+    if (collected_index_count !== pool_size) {
+        throw new Error(`BVH8 references ${collected_index_count} pool entries, pool holds ${pool_size}`);
+    }
+
+    collected_indices.sort(number_compare_ascending);
+    for (let i = 0; i < collected_index_count; i++) {
+        if (collected_indices[i] !== i) {
+            throw new Error(`Missing pool index ${i}`);
+        }
+    }
+
+    // pool entries must be a permutation of the geometry triangles
+    const seen = new Uint8Array(triangle_count);
+    const pool = bvh.primitives.data_uint32;
+
+    for (let i = 0; i < pool_size; i++) {
+        const triangle = pool[i];
+
+        if (triangle >= triangle_count) {
+            throw new Error(`pool entry ${i} references triangle ${triangle}, geometry has ${triangle_count}`);
+        }
+
+        if (seen[triangle] !== 0) {
+            throw new Error(`triangle ${triangle} is referenced more than once`);
+        }
+
+        seen[triangle] = 1;
+    }
+
+    const geometry_bounds = new AABB3();
+    aabb3_from_v3_array(geometry_bounds, position_array, position_array.length);
+    aabb3_round_to_float32(geometry_bounds);
+
+    // check bounds
+    bvh8_geometry_validate_bounds_indirect(bvh, geometry_bounds, index_array, position_array);
+}

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

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ */
+export function bvh8_get_node_bounds(out: number[] | Float32Array, out_offset: number, bvh: BVH8, node: number): void;
+//# sourceMappingURL=bvh8_get_node_bounds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_get_node_bounds.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_get_node_bounds.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,0CALW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,mBAEN,MAAM,QAuBhB"}

package/src/core/bvh8/bvh8_get_node_bounds.js

@@ -0,0 +1,35 @@
+import { array_copy } from "../collection/array/array_copy.js";
+import { aabb3_array_combine } from "../geom/3d/aabb/aabb3_array_combine.js";
+import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
+
+const scratch_f32 = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ */
+export function bvh8_get_node_bounds(out, out_offset, bvh, node) {
+    let processed_count = 0;
+
+    for (let i = 0; i < 8; i++) {
+        const meta = bvh.node_get_meta(node, i);
+
+        if (meta === 0) {
+            // empty, skip
+            continue;
+        }
+
+        bvh8_get_node_child_bounds(scratch_f32, 0, bvh, node, i);
+
+        if (processed_count === 0) {
+            array_copy(scratch_f32, 0, out, out_offset, 6);
+        } else {
+            aabb3_array_combine(out, out_offset, out, out_offset, scratch_f32, 0);
+        }
+
+        processed_count++;
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ */
+export function bvh8_get_node_child_bounds(out: number[] | Float32Array, out_offset: number, bvh: BVH8, node: number, child: number): void;
+//# sourceMappingURL=bvh8_get_node_child_bounds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_get_node_child_bounds.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_get_node_child_bounds.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,gDANW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,mBAEN,MAAM,SACN,MAAM,QAwChB"}