@woosh/meep-engine 2.156.0 → 2.158.0

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

@@ -0,0 +1,303 @@
+import { assert } from "../../assert.js";
+import { build_triangle_morton_codes } from "../../bvh2/bvh3/build_triangle_morton_codes.js";
+import {
+    array_quick_sort_by_lookup_uint
+} from "../../collection/array/array_quick_sort_by_lookup_uint.js";
+import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
+import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
+import v3_morton_encode from "../../geom/3d/morton/v3_morton_encode.js";
+import { aabb3_compute_from_triangle } from "../../geom/3d/triangle/aabb3_compute_from_triangle.js";
+import { BVH8_MAX_LEAF_TRIANGLE_OFFSET } from "../BVH8.js";
+import { aabb3_compute_merge_cost } from "./aabb3_compute_merge_cost.js";
+import { aabb3_from_triangle_by_index } from "./aabb3_from_triangle_by_index.js";
+import { bvh8_from_proxy } from "./bvh8_from_proxy.js";
+import { NodeProxy } from "./NodeProxy.js";
+
+/**
+ *
+ * @param {BVH8} bvh8 output
+ * @param {number[] | Uint32Array | Uint16Array} index_array
+ * @param {number[] | Float32Array | Float64Array} position_array
+ * @param {AABB3} [bounds]
+ */
+export function bvh8_build_for_geometry(
+    bvh8,
+    index_array,
+    position_array,
+    bounds
+) {
+
+    const tri_count = index_array.length / 3;
+
+    if (tri_count === 0) {
+        // empty geometry, empty tree
+        bvh8.clear();
+        return;
+    }
+
+    // indices of triangles, but sorted by morton codes
+    const sorted_triangle_order = new Uint32Array(tri_count);
+
+    for (let i = 0; i < tri_count; i++) {
+        sorted_triangle_order[i] = i;
+    }
+
+    let _geometry_bounds = bounds;
+
+    if (_geometry_bounds === undefined) {
+        // get bounds for the entire geometry
+        _geometry_bounds = new AABB3();
+
+        aabb3_from_v3_array(_geometry_bounds, position_array, position_array.length);
+    } else {
+
+        assert.greaterThanOrEqual(_geometry_bounds.width, 0, 'x extents');
+        assert.greaterThanOrEqual(_geometry_bounds.height, 0, 'y extents');
+        assert.greaterThanOrEqual(_geometry_bounds.depth, 0, 'z extents');
+
+    }
+
+    const morton_codes = new Uint32Array(tri_count);
+
+    build_triangle_morton_codes(
+        morton_codes,
+        tri_count,
+        index_array,
+        position_array,
+        _geometry_bounds.x0, _geometry_bounds.y0, _geometry_bounds.z0,
+        _geometry_bounds.x1, _geometry_bounds.y1, _geometry_bounds.z1
+    );
+
+
+    // sort leaves by morton codes
+    array_quick_sort_by_lookup_uint(sorted_triangle_order, morton_codes, 0, tri_count - 1);
+
+    // we build the tree bottom-up
+
+    const scratch_aabb = new Float32Array(6);
+
+    /**
+     *
+     * @type {NodeProxy[]}
+     */
+    const nodes = [];
+
+
+    for (let i = 0; i < tri_count;) {
+        const first_primitive = sorted_triangle_order[i];
+
+        let triangle_index_low = first_primitive;
+        let triangle_index_high = first_primitive;
+
+        const node = new NodeProxy()
+        aabb3_compute_from_triangle(node.bounds, 0, position_array,
+            index_array[first_primitive * 3],
+            index_array[first_primitive * 3 + 1],
+            index_array[first_primitive * 3 + 2],
+        );
+        node.tryAddPrimitive(first_primitive, node.bounds);
+        i++;
+
+        let node_primitive_count = 1;
+
+        // a leaf meta can only address triangles up to BVH8_MAX_LEAF_TRIANGLE_OFFSET
+        // forward from the node's base triangle index
+        while (i < tri_count) {
+            const index = sorted_triangle_order[i];
+
+            if (index < triangle_index_low) {
+                triangle_index_low = index;
+            } else if (index > triangle_index_high) {
+                triangle_index_high = index;
+            }
+
+            const triangle_index_span = triangle_index_high - triangle_index_low;
+            if (triangle_index_span > BVH8_MAX_LEAF_TRIANGLE_OFFSET) {
+                // next index is outside the range
+                break;
+            }
+
+
+            // compute triangle surface area
+            aabb3_from_triangle_by_index(scratch_aabb, 0, index, index_array, position_array);
+
+
+            if (aabb3_compute_merge_cost(scratch_aabb, node.bounds) > 3) {
+                // too expensive to absorb triangle
+                break;
+            }
+
+            if (!node.tryAddPrimitive(index, scratch_aabb)) {
+                break;
+            }
+
+            node_primitive_count++;
+
+            aabb3_array_combine(scratch_aabb, 0, node.bounds, 0, scratch_aabb, 0);
+
+            node.bounds.set(scratch_aabb);
+
+            i++;
+
+        }
+
+        node.primitive_count = node_primitive_count;
+
+        nodes.push(node);
+    }
+
+    const aabb_size_x = _geometry_bounds[3] - _geometry_bounds[0];
+    const aabb_size_y = _geometry_bounds[4] - _geometry_bounds[1];
+    const aabb_size_z = _geometry_bounds[5] - _geometry_bounds[2];
+
+    // compute multipliers to bring normalized values in range of 10bit unsigned integer each
+    const morton_scale_x = aabb_size_x === 0 ? 0 : 1023 / aabb_size_x;
+    const morton_scale_y = aabb_size_y === 0 ? 0 : 1023 / aabb_size_y;
+    const morton_scale_z = aabb_size_z === 0 ? 0 : 1023 / aabb_size_z;
+
+    /**
+     *
+     * @param {NodeProxy} node
+     * @return {number}
+     */
+    function morton_code(node) {
+        const center_x = (node.bounds[0] + node.bounds[3]) * 0.5;
+        const center_y = (node.bounds[1] + node.bounds[4]) * 0.5;
+        const center_z = (node.bounds[2] + node.bounds[5]) * 0.5;
+
+        // normalize to 10bit range; node bounds are stored in 32-bit floats and can poke
+        // slightly outside the 64-bit geometry bounds, so clamp
+        const ncx = Math.min(1023, Math.max(0, (center_x - _geometry_bounds[0]) * morton_scale_x));
+        const ncy = Math.min(1023, Math.max(0, (center_y - _geometry_bounds[1]) * morton_scale_y));
+        const ncz = Math.min(1023, Math.max(0, (center_z - _geometry_bounds[2]) * morton_scale_z));
+
+        return v3_morton_encode(
+            Math.round(ncx),
+            Math.round(ncy),
+            Math.round(ncz),
+        )
+    }
+
+    /**
+     *
+     * @param {NodeProxy} n0
+     * @param {NodeProxy} n1
+     * @return {number}
+     */
+    function by_morton_code(n0, n1) {
+        const m0 = morton_code(n0);
+        const m1 = morton_code(n1);
+
+        const morton_difference = m0 - m1;
+
+        if (morton_difference !== 0) {
+            return morton_difference;
+        }
+
+        return n0.primitive_count - n1.primitive_count;
+    }
+
+    const MERGE_LOOK_AHEAD_DISTANCE_BASE = 18;
+    const MERGE_LOOK_AHEAD_PER_NODE_BOOST = 2;
+
+    /**
+     *
+     * @param {NodeProxy} stem
+     * @param {NodeProxy}  addition
+     */
+    function compute_merge_cost(stem, addition) {
+
+        aabb3_array_combine(scratch_aabb, 0, stem.bounds, 0, addition.bounds, 0);
+
+        const combined_area = aabb3_compute_surface_area(...scratch_aabb);
+
+        // simplified surface area heuristic
+        return combined_area;
+    }
+
+    // assemble tree
+    while (nodes.length > 1) {
+
+        // sort nodes
+        nodes.sort(by_morton_code);
+
+        for (let i = nodes.length - 1; i >= 0;) {
+
+            const seed_node = nodes[i];
+
+
+            /**
+             * @type {NodeProxy}
+             */
+            const parent = new NodeProxy();
+            nodes[i] = parent;
+
+            i--;
+
+            parent.addChild(seed_node);
+
+            // look for candidates to merge with this node
+            // look-ahead for potential matches
+            while (parent.used_slot_count < 8 && i >= 0) {
+                let best_match_index = i;
+                let best_match = nodes[best_match_index];
+                let best_cost = compute_merge_cost(parent, best_match);
+
+                const look_ahead_boost = MERGE_LOOK_AHEAD_PER_NODE_BOOST * parent.children.length;
+
+                const look_ahead = Math.min(
+                    MERGE_LOOK_AHEAD_DISTANCE_BASE + look_ahead_boost,
+                    i
+                );
+
+                for (let j = 1; j <= look_ahead; j++) {
+                    const node_index = i - j;
+                    const node = nodes[node_index];
+
+                    // prefer leaf nodes
+                    const cost = compute_merge_cost(parent, node);
+
+                    if (
+                        cost < best_cost
+                        || (
+                            cost === best_cost
+                            && (
+                                node.height < best_match.height
+                                || node.primitive_count < best_match.primitive_count
+                            )
+                        )) {
+                        best_match_index = node_index;
+                        best_match = node;
+                        best_cost = cost;
+                    }
+                }
+
+                const current_child_count = parent.children.length;
+                if (
+                    current_child_count > 1
+                    // as number of children increases, so does penalty for nodes being too far
+                    && aabb3_compute_merge_cost(best_match.bounds, parent.bounds) > (1 + 2 / current_child_count)
+                ) {
+                    // we already have at least 2 nodes grouped, and new node is too far away, finalize this root
+                    break;
+                }
+
+                // absorb best match
+                parent.addChild(best_match);
+
+                nodes.splice(best_match_index, 1);
+                i--;
+            }
+
+
+            // see if we can absorb any children
+            parent.optimize_pull_up(index_array, position_array);
+        }
+
+    }
+
+    // build BVH8 from proxy nodes
+    bvh8_from_proxy(bvh8, nodes[0], index_array, position_array);
+}

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

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {BVH8} bvh8
+ * @param {NodeProxy} root
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function bvh8_from_proxy(bvh8: BVH8, root: NodeProxy, index_array: number[], position_array: number[]): void;
+//# sourceMappingURL=bvh8_from_proxy.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,256 @@
+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 { byte } from "./byte.js";
+import { encode_bounds_e } from "./encode_bounds_e.js";
+
+/**
+ *
+ * @param {NodeProxy} node
+ * @param {{bounds:Float32Array}[]} children
+ * @param {number} child_count
+ */
+function bvh8_sort_children(node, children, child_count) {
+    const center_x = (node.bounds[0] + node.bounds[3]) * 0.5;
+    const center_y = (node.bounds[1] + node.bounds[4]) * 0.5;
+    const center_z = (node.bounds[2] + node.bounds[5]) * 0.5;
+
+    const cost = new Float32Array(8 * 8);
+
+    // Fill cost table
+    for (let c = 0; c < child_count; c++) {
+        for (let s = 0; s < 8; s++) {
+            const d_x = (s & 0b100) ? -1.0 : +1.0;
+            const d_y = (s & 0b010) ? -1.0 : +1.0;
+            const d_z = (s & 0b001) ? -1.0 : +1.0;
+
+            const aabb = children[c].bounds;
+
+            const child_center_x = (aabb[0] + aabb[3]) * 0.5;
+            const child_center_y = (aabb[1] + aabb[4]) * 0.5;
+            const child_center_z = (aabb[2] + aabb[5]) * 0.5;
+
+            const child_offset_x = child_center_x - center_x;
+            const child_offset_y = child_center_y - center_y;
+            const child_offset_z = child_center_z - center_z;
+
+            cost[c * 8 + s] = v3_dot(
+                child_offset_x, child_offset_y, child_offset_z,
+                d_x, d_y, d_z
+            );
+        }
+    }
+
+    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;
+    }
+
+    // Permute children array according to assignment
+    const children_copy = new Array(8);
+    for (let i = 0; i < 8; i++) {
+        children_copy[i] = children[i];
+        children[i] = undefined;
+    }
+
+    for (let i = 0; i < child_count; i++) {
+        children[assignment[i]] = children_copy[i];
+    }
+}
+
+/**
+ * Emit a single BVH8 node from a proxy node, pushing (proxy, node_id) pairs for the internal
+ * children onto the stack in reverse slot order, so they are popped in ascending slot order —
+ * the same depth-first layout the recursive formulation produces.
+ * @param {BVH8} bvh8
+ * @param {number} node_id
+ * @param {NodeProxy} proxy
+ * @param {number[] | Uint32Array | Uint16Array} index_array
+ * @param {number[] | Float32Array | Float64Array} position_array
+ * @param {Array} stack
+ */
+function bvh8_populate_node_from_proxy(
+    bvh8,
+    node_id,
+    proxy,
+    index_array,
+    position_array,
+    stack
+) {
+
+    const node_p_x = proxy.bounds[0];
+    const node_p_y = proxy.bounds[1];
+    const node_p_z = proxy.bounds[2];
+
+    bvh8.node_set_p(node_id, node_p_x, node_p_y, node_p_z);
+
+    const Nq = 8;
+    const denom = 1.0 / ((1 << Nq) - 1);
+
+    const e_x = encode_bounds_e(node_p_x, proxy.bounds[3], denom);
+    const e_y = encode_bounds_e(node_p_y, proxy.bounds[4], denom);
+    const e_z = encode_bounds_e(node_p_z, proxy.bounds[5], denom);
+
+    const one_over_e_x = 1 / e_x;
+    const one_over_e_y = 1 / e_y;
+    const one_over_e_z = 1 / e_z;
+
+    const u_ex = reinterpret_float32_as_uint32(e_x);
+    const u_ey = reinterpret_float32_as_uint32(e_y);
+    const u_ez = reinterpret_float32_as_uint32(e_z);
+
+    // Only the exponent bits can be non-zero
+    assert.equal(u_ex & 0b10000000011111111111111111111111, 0);
+    assert.equal(u_ey & 0b10000000011111111111111111111111, 0);
+    assert.equal(u_ez & 0b10000000011111111111111111111111, 0);
+
+    // Store only 8 bit exponent
+    bvh8.node_set_e(node_id, u_ex >> 23, u_ey >> 23, u_ez >> 23);
+
+    const child_count = proxy.children.length;
+    const index_offset_child = bvh8.allocate_nodes(child_count);
+    let index_offset_triangle = 0;
+    if (proxy.primitives.length > 0) {
+        index_offset_triangle = proxy.primitive_index_low;
+    }
+
+    bvh8.node_set_base_index_child(node_id, index_offset_child);
+    bvh8.node_set_base_index_triangle(node_id, index_offset_triangle);
+
+    // create children
+    const children = proxy.children.slice();
+    if (proxy.primitives.length === 0) {
+        // no primitives
+    } else {
+        Array.prototype.push.apply(children, proxy.primitives)
+    }
+
+    let imask = 0;
+    let num_internal = 0;
+
+    // sort children
+    bvh8_sort_children(proxy, children, children.length);
+
+    for (let i = 0; i < 8; i++) {
+        const child = children[i];
+
+        let meta = 0;
+
+        if (child === undefined) {
+            // empty slot
+            continue;
+        } else if (child.isNodeProxy === true) {
+            imask |= 1 << i;
+            num_internal++;
+
+            meta = 0b00100000 | (24 + i);
+        } else {
+            // primitive node
+            let min_triangle_index = 24;
+            const num_triangles = child.triangles.length;
+
+            assert.lessThanOrEqual(num_triangles, 3);
+
+            for (let j = 0; j < num_triangles; j++) {
+                meta |= (1 << (j + 5));
+
+                const triangle = child.triangles[j];
+
+                const triangle_local_offset = triangle - index_offset_triangle;
+
+                if (min_triangle_index > triangle_local_offset) {
+                    min_triangle_index = triangle_local_offset;
+                }
+            }
+
+            meta |= min_triangle_index;
+        }
+
+        bvh8.node_set_meta(node_id, i, meta);
+
+        const child_aabb = child.bounds;
+
+        bvh8.node_set_quantized_min(
+            node_id, i,
+            byte(Math.floor((child_aabb[0] - node_p_x) * one_over_e_x)),
+            byte(Math.floor((child_aabb[1] - node_p_y) * one_over_e_y)),
+            byte(Math.floor((child_aabb[2] - node_p_z) * one_over_e_z))
+        );
+
+        bvh8.node_set_quantized_max(
+            node_id, i,
+            byte(Math.ceil((child_aabb[3] - node_p_x) * one_over_e_x)),
+            byte(Math.ceil((child_aabb[4] - node_p_y) * one_over_e_y)),
+            byte(Math.ceil((child_aabb[5] - node_p_z) * one_over_e_z))
+        );
+    }
+
+    bvh8.node_set_imask(node_id, imask);
+
+    // queue intermediate children, in reverse slot order so they pop in ascending order
+    let child_index = num_internal;
+    for (let i = 7; i >= 0; i--) {
+        if ((imask & (1 << i)) === 0) {
+            // no intermediate node
+            continue;
+        }
+
+        child_index--;
+
+        stack.push(children[i], index_offset_child + child_index);
+    }
+}
+
+/**
+ *
+ * @param {BVH8} bvh8
+ * @param {NodeProxy} root
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function bvh8_from_proxy(bvh8, root, index_array, position_array) {
+    bvh8.clear();
+
+    const root8 = bvh8.allocate_node();
+
+    // (proxy, node_id) pairs
+    const stack = [root, root8];
+
+    while (stack.length > 0) {
+        const node_id = stack.pop();
+        const proxy = stack.pop();
+
+        bvh8_populate_node_from_proxy(bvh8, node_id, proxy, index_array, position_array, stack);
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} float_value
+ * @return {number}
+ */
+export function byte(float_value: number): number;
+//# sourceMappingURL=byte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"byte.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/byte.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,kCAHW,MAAM,GACL,MAAM,CAMjB"}

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

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} float_value
+ * @return {number}
+ */
+export function byte(float_value) {
+    const u32 = float_value >>> 0;
+
+    return u32 & 0xFF;
+}

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

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number} min
+ * @param {number} max
+ * @param {number} denom
+ * @returns {number}
+ */
+export function encode_bounds_e(min: number, max: number, denom: number): number;
+//# sourceMappingURL=encode_bounds_e.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode_bounds_e.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/encode_bounds_e.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,qCALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB"}

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

@@ -0,0 +1,12 @@
+import { exp2 } from "../../math/exp2.js";
+
+/**
+ *
+ * @param {number} min
+ * @param {number} max
+ * @param {number} denom
+ * @returns {number}
+ */
+export function encode_bounds_e(min, max, denom) {
+    return exp2(Math.ceil(Math.log2((max - min) * denom)));
+}

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

@@ -0,0 +1,11 @@
+/**
+ * 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: BVH8, root?: number): string;
+//# sourceMappingURL=bvh8_convert_to_dot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_convert_to_dot.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_convert_to_dot.js"],"names":[],"mappings":"AAoGA;;;;;;;;GAQG;AACH,sDAHW,MAAM,GACJ,MAAM,CAyBlB"}