@woosh/meep-engine 2.156.0 → 2.158.0

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

@@ -0,0 +1,588 @@
+import { assert } from "../../assert.js";
+import { reinterpret_float32_as_uint32 } from "../../binary/reinterpret_float32_as_uint32.js";
+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 { byte } from "./byte.js";
+import { encode_bounds_e } from "./encode_bounds_e.js";
+
+/**
+ *
+ * @enum {number}
+ */
+const DECISION_TYPE = {
+    LEAF: 0,
+    INTERNAL: 1,
+    DISTRIBUTE: 2
+}
+
+const DECISION_BYTE_SIZE = 7;
+
+/**
+ *
+ * @type {number}
+ */
+const INVALID = 0xFFFFFFFF;
+
+const DECISION_OFFSET_TYPE = 0;
+const DECISION_OFFSET_DISTRIBUTE_LEFT = 1;
+const DECISION_OFFSET_DISTRIBUTE_RIGHT = 2;
+const DECISION_OFFSET_COST = 3;
+
+const GET_CHILDREN_OP_EXPAND = 0;
+const GET_CHILDREN_OP_EMIT = 1;
+
+
+/**
+ * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/BVH/Converters/BVH8Converter.h#L4
+ */
+export class BVH8Converter {
+    /**
+     * Binary BVH
+     * @type {BVH}
+     */
+    bvh2
+
+    /**
+     * @type {BVH8}
+     */
+    bvh8
+
+    /**
+     *
+     * @param {BVH8} bvh8
+     * @param {BVH} bvh2
+     */
+    constructor(bvh8, bvh2) {
+        this.bvh8 = bvh8;
+        this.bvh2 = bvh2;
+    }
+
+    /**
+     *
+     * @type {BinaryElementPool}
+     */
+    #decisions = new BinaryElementPool(DECISION_BYTE_SIZE);
+
+    /**
+     * Fill the decision table for the subtree of the given node, bottom-up.
+     * @param {number} node_index
+     * @returns {number} number of primitives under the given root
+     */
+    calculate_cost(node_index) {
+        const decisions = this.#decisions;
+        const bvh2 = this.bvh2;
+
+        // record pre-order with children pushed; processing it in reverse yields a post-order
+        // sequence, so every node's children are processed before the node itself
+        const order = [];
+        const discovery = [node_index];
+
+        while (discovery.length > 0) {
+            const node = discovery.pop();
+            order.push(node);
+
+            if (!bvh2.node_is_leaf(node)) {
+                discovery.push(bvh2.node_get_child1(node));
+                discovery.push(bvh2.node_get_child2(node));
+            }
+        }
+
+        const primitive_counts = new Uint32Array(bvh2.size);
+
+        for (let k = order.length - 1; k >= 0; k--) {
+            const node = order[k];
+
+            const node_surface_area = bvh2.node_get_surface_area(node);
+
+            if (bvh2.node_is_leaf(node)) {
+                const num_primitives = 1;
+
+                // SAH cost
+                const cost_leaf = node_surface_area * num_primitives;
+
+                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);
+                }
+
+                primitive_counts[node] = num_primitives;
+
+            } else {
+                const left = bvh2.node_get_child1(node);
+                const right = bvh2.node_get_child2(node);
+
+                const num_primitives = primitive_counts[left] + primitive_counts[right];
+
+                // 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;
+
+                    let cost_distribute = Infinity;
+
+                    let distribute_left = INVALID;
+                    let distribute_right = INVALID;
+
+                    for (let k = 0; k < 7; k++) {
+                        const address_0 = decisions.element_address(left * 7 + k);
+                        const address_1 = decisions.element_address(right * 7 + (6 - k));
+
+
+                        const c =
+                            decisions.data_view.getFloat32(address_0 + DECISION_OFFSET_COST) +
+                            decisions.data_view.getFloat32(address_1 + DECISION_OFFSET_COST);
+
+                        if (c < cost_distribute) {
+                            cost_distribute = c;
+
+                            distribute_left = k;
+                            distribute_right = 6 - k;
+                        }
+                    }
+
+                    const cost_internal = cost_distribute + node_surface_area;
+
+                    const decision_ptr = decisions.element_address(node * 7);
+
+                    if (cost_leaf < cost_internal) {
+                        decisions.data_view.setUint8(decision_ptr, DECISION_TYPE.LEAF);
+                        decisions.data_view.setFloat32(decision_ptr + DECISION_OFFSET_COST, cost_leaf);
+                    } else {
+                        decisions.data_view.setUint8(decision_ptr, DECISION_TYPE.INTERNAL);
+                        decisions.data_view.setFloat32(decision_ptr + DECISION_OFFSET_COST, cost_internal);
+                    }
+
+                    decisions.data_view.setUint8(decision_ptr + DECISION_OFFSET_DISTRIBUTE_LEFT, distribute_left);
+                    decisions.data_view.setUint8(decision_ptr + DECISION_OFFSET_DISTRIBUTE_RIGHT, distribute_right);
+                }
+
+                // In the paper i=2..7
+                // create a forest of up to i roots
+                for (let i = 1; i < 7; i++) {
+                    const decision_ptr_i = decisions.element_address(node * 7 + i - 1);
+
+                    let cost_distribute = decisions.data_view.getFloat32(decision_ptr_i + DECISION_OFFSET_COST);
+
+                    let distribute_left = INVALID;
+                    let distribute_right = INVALID;
+
+                    for (let k = 0; k < i; k++) {
+                        const address_0 = decisions.element_address(left * 7 + k);
+                        const address_1 = decisions.element_address(right * 7 + i - k - 1);
+
+
+                        const c =
+                            decisions.data_view.getFloat32(address_0 + DECISION_OFFSET_COST) +
+                            decisions.data_view.getFloat32(address_1 + DECISION_OFFSET_COST);
+
+                        if (c < cost_distribute) {
+                            cost_distribute = c;
+
+                            distribute_left = k;
+                            distribute_right = i - k - 1;
+                        }
+                    }
+
+                    const decision_ptr = decisions.element_address(node * 7 + i);
+                    decisions.data_view.setFloat32(decision_ptr + DECISION_OFFSET_COST, cost_distribute);
+
+                    if (distribute_left !== INVALID) {
+                        decisions.data_view.setUint8(decision_ptr, DECISION_TYPE.DISTRIBUTE);
+                        decisions.data_view.setUint8(decision_ptr + DECISION_OFFSET_DISTRIBUTE_LEFT, distribute_left);
+                        decisions.data_view.setUint8(decision_ptr + DECISION_OFFSET_DISTRIBUTE_RIGHT, distribute_right);
+
+                    } else {
+
+                        // no distribution beats the smaller forest, inherit its decision wholesale
+                        for (let j = 0; j < 7; j++) {
+                            decisions.data_view.setUint8(decision_ptr + j,
+                                decisions.data_view.getUint8(decision_ptr_i + j)
+                            );
+                        }
+
+                    }
+                }
+
+                primitive_counts[node] = num_primitives;
+            }
+        }
+
+        return primitive_counts[node_index];
+    }
+
+    /**
+     * Resolve the BVH2 nodes that become the children of a BVH8 node, following the
+     * DISTRIBUTE decisions recorded by {@link BVH8Converter#calculate_cost}.
+     * @param {number} node_index
+     * @param {number[]|Uint32Array} children
+     * @param {number} child_offset
+     * @param {number} i
+     * @returns {number} number of children written
+     */
+    get_children(node_index, children, child_offset, i) {
+        const decisions = this.#decisions;
+        const bvh2 = this.bvh2;
+
+        let count = 0;
+
+        // entries are (decision_index, node, op) triples; right entries are pushed before left
+        // ones so that the left subtree is fully expanded first, preserving child order
+        const stack = [i, node_index, GET_CHILDREN_OP_EXPAND];
+
+        while (stack.length > 0) {
+            const op = stack.pop();
+            const node = stack.pop();
+            const decision_i = stack.pop();
+
+            if (op === GET_CHILDREN_OP_EMIT || bvh2.node_is_leaf(node)) {
+                children[child_offset + count] = node;
+                count++;
+                continue;
+            }
+
+            const decision_ptr = decisions.element_address(node * 7 + decision_i);
+
+            const distribute_left = decisions.data_view.getUint8(decision_ptr + DECISION_OFFSET_DISTRIBUTE_LEFT);
+            const distribute_right = decisions.data_view.getUint8(decision_ptr + DECISION_OFFSET_DISTRIBUTE_RIGHT);
+
+
+            assert.ok(distribute_left >= 0 && distribute_left < 7);
+            assert.ok(distribute_right >= 0 && distribute_right < 7);
+
+            const left = bvh2.node_get_child1(node);
+            const right = bvh2.node_get_child2(node);
+
+            const decision_left_type = decisions.data_view.getUint8(decisions.element_address(left * 7 + distribute_left));
+            const decision_right_type = decisions.data_view.getUint8(decisions.element_address(right * 7 + distribute_right));
+
+            stack.push(
+                distribute_right,
+                right,
+                decision_right_type === DECISION_TYPE.DISTRIBUTE ? GET_CHILDREN_OP_EXPAND : GET_CHILDREN_OP_EMIT
+            );
+
+            stack.push(
+                distribute_left,
+                left,
+                decision_left_type === DECISION_TYPE.DISTRIBUTE ? GET_CHILDREN_OP_EXPAND : GET_CHILDREN_OP_EMIT
+            );
+        }
+
+        return count;
+    }
+
+    /**
+     *
+     * @param {number} node_index
+     * @param {number[]|Uint32Array} children
+     * @param {number} child_count
+     */
+    order_children(node_index, children, child_count) {
+        const aabb = new Float32Array(6);
+        this.bvh2.node_get_aabb(node_index, aabb);
+
+        const center_x = (aabb[0] + aabb[3]) * 0.5;
+        const center_y = (aabb[1] + aabb[4]) * 0.5;
+        const center_z = (aabb[2] + aabb[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;
+
+                this.bvh2.node_get_aabb(children[c], aabb);
+
+                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 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 Uint32Array(8);
+        for (let i = 0; i < 8; i++) {
+            children_copy[i] = children[i];
+            children[i] = INVALID;
+        }
+
+        for (let i = 0; i < child_count; i++) {
+            assert.notEqual(assignment   [i], INVALID);
+            assert.notEqual(children_copy[i], INVALID);
+            children[assignment[i]] = children_copy[i];
+        }
+    }
+
+    /**
+     * Count triangles in the subtree of the given BVH2 node.
+     * Simultaneously fills the indices buffer of the BVH8, in left-to-right leaf order.
+     * @param {number} node_index
+     * @returns {number}
+     */
+    count_primitives(node_index) {
+        assert.notEqual(node_index, NULL_NODE);
+
+        const bvh2 = this.bvh2;
+        const primitives = this.bvh8.primitives;
+
+        let count = 0;
+
+        const stack = [node_index];
+
+        while (stack.length > 0) {
+            const node = stack.pop();
+
+            if (bvh2.node_is_leaf(node)) {
+
+                const prim = primitives.allocate();
+
+                primitives.data_uint32[prim] = bvh2.node_get_user_data(node);
+
+                count++;
+
+            } else {
+
+                // push right first, so the left leaf run is emitted first
+                stack.push(bvh2.node_get_child2(node));
+                stack.push(bvh2.node_get_child1(node));
+
+            }
+        }
+
+        return count;
+    }
+
+    /**
+     * Build the BVH8 subtree for a BVH2 subtree.
+     * @param {number} node_index_bvh8
+     * @param {number} node_index_bvh2
+     */
+    collapse(node_index_bvh8, node_index_bvh2) {
+        // (bvh2, bvh8) index pairs
+        const stack = [node_index_bvh2, node_index_bvh8];
+
+        while (stack.length > 0) {
+            const bvh8_node = stack.pop();
+            const bvh2_node = stack.pop();
+
+            this.#collapse_node(bvh8_node, bvh2_node, stack);
+        }
+    }
+
+    /**
+     * Emit a single BVH8 node from a BVH2 subtree root, pushing (bvh2, bvh8) 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 {number} node_index_bvh8
+     * @param {number} node_index_bvh2
+     * @param {number[]} stack
+     */
+    #collapse_node(node_index_bvh8, node_index_bvh2, stack) {
+        const aabb = new Float32Array(6);
+
+        this.bvh2.node_get_aabb(node_index_bvh2, aabb);
+
+        const node_p_x = aabb[0];
+        const node_p_y = aabb[1];
+        const node_p_z = aabb[2];
+
+        this.bvh8.node_set_p(node_index_bvh8, 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, aabb[3], denom);
+        const e_y = encode_bounds_e(node_p_y, aabb[4], denom);
+        const e_z = encode_bounds_e(node_p_z, aabb[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
+        this.bvh8.node_set_e(node_index_bvh8, u_ex >> 23, u_ey >> 23, u_ez >> 23);
+
+        const children = new Uint32Array(8);
+        children.fill(INVALID);
+
+        const child_count = this.get_children(node_index_bvh2, children, 0, 0);
+
+        assert.lessThanOrEqual(child_count, 8);
+
+        this.order_children(node_index_bvh2, children, child_count);
+
+        let imask = 0;
+
+        const base_index_triangle = this.bvh8.primitives.size;
+        this.bvh8.node_set_base_index_triangle(node_index_bvh8, base_index_triangle);
+
+        const base_index_child = this.bvh8.nodes.size;
+        this.bvh8.node_set_base_index_child(node_index_bvh8, base_index_child);
+
+        let num_internal_nodes = 0;
+        let num_triangles = 0;
+
+        for (let i = 0; i < 8; i++) {
+            const child_index = children[i];
+
+            if (child_index === INVALID) {
+                // Empty slot
+                continue;
+            }
+
+            const child_aabb = new Float32Array(6);
+            this.bvh2.node_get_aabb(child_index, child_aabb);
+
+            this.bvh8.node_set_quantized_min(
+                node_index_bvh8, 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))
+            );
+
+            this.bvh8.node_set_quantized_max(
+                node_index_bvh8, 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))
+            );
+
+            const child_decision_ptr = this.#decisions.element_address(child_index * 7);
+
+            const child_decision_type = this.#decisions.data_view.getUint8(child_decision_ptr);
+
+            let child_meta = 0;
+
+            switch (child_decision_type) {
+                case DECISION_TYPE.LEAF: {
+                    const triangle_count = this.count_primitives(child_index);
+                    assert.ok(triangle_count > 0 && triangle_count <= 3);
+
+                    // Three highest bits contain unary representation of triangle count
+                    for (let j = 0; j < triangle_count; j++) {
+                        child_meta |= (1 << (j + 5));
+                    }
+
+                    child_meta |= num_triangles;
+
+                    num_triangles += triangle_count;
+                    assert.lessThanOrEqual(num_triangles, 24);
+                    break;
+                }
+                case DECISION_TYPE.INTERNAL: {
+                    child_meta = (i + 24) | 0b00100000;
+
+                    imask |= (1 << i);
+                    num_internal_nodes++;
+                    break;
+                }
+                default:
+                    throw new Error('Unsupported decision')
+            }
+
+            this.bvh8.node_set_meta(node_index_bvh8, i, child_meta);
+        }
+
+        this.bvh8.node_set_imask(node_index_bvh8, imask);
+
+        this.bvh8.allocate_nodes(num_internal_nodes);
+
+        assert.equal(base_index_child + num_internal_nodes, this.bvh8.nodes.size);
+        assert.equal(base_index_triangle + num_triangles, this.bvh8.primitives.size);
+
+        // queue internal children, in reverse slot order so they pop in ascending order
+        let offset = num_internal_nodes;
+        for (let i = 7; i >= 0; i--) {
+            const child_index = children[i];
+
+            if (child_index === INVALID) {
+                continue;
+            }
+
+            if ((imask & (1 << i)) !== 0) {
+                offset--;
+                stack.push(child_index, base_index_child + offset);
+            }
+        }
+    }
+
+    convert() {
+        // initialize decision table
+        this.#decisions.clear();
+        this.#decisions.allocate_continuous(this.bvh2.size * 7);
+
+        this.bvh8.clear();
+
+        const root2 = this.bvh2.root;
+
+        if (root2 === NULL_NODE) {
+            // source is empty
+            return;
+        }
+
+        const root8 = this.bvh8.allocate_node();
+
+        // Fill cost table using dynamic programming (bottom up)
+        this.calculate_cost(root2);
+
+        this.collapse(root8, root2);
+    }
+}

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

@@ -0,0 +1,66 @@
+export class NodeProxy {
+    /**
+     *
+     * @type {TriangleCluster[]}
+     */
+    primitives: TriangleCluster[];
+    primitive_index_low: number;
+    primitive_index_high: number;
+    /**
+     *
+     * @type {NodeProxy[]}
+     */
+    children: NodeProxy[];
+    bounds: Float32Array;
+    height: number;
+    computeHeight(): void;
+    primitive_count: number;
+    /**
+     *
+     * @param {NodeProxy} other
+     * @returns {number}
+     */
+    computeCentroidSqrDistanceTo(other: NodeProxy): number;
+    computePrimitiveBounds(index_array: any, position_array: any): void;
+    /**
+     * A node has 8 slots that can be used for either triangle clusters or children
+     * @returns {number}
+     */
+    get used_slot_count(): number;
+    recomputePrimitiveSpan(): void;
+    /**
+     *
+     * @param {number} index
+     * @param {number[]|Float32Array} bounds
+     * @returns {boolean} true if added, false otherwise
+     */
+    tryAddPrimitive(index: number, bounds: number[] | Float32Array): boolean;
+    addChild(node: any): void;
+    /**
+     * Attempt to pull up data from children and in process reduce number of nodes below
+     */
+    optimize_pull_up(index_array: any, position_array: any): void;
+    /**
+     *
+     * @param {NodeProxy} child
+     * @param {number[]} index_array
+     * @param {number[]} position_array
+     * @return {boolean}
+     */
+    tryAbsorbChild(child: NodeProxy, index_array: number[], position_array: number[]): boolean;
+    /**
+     * Mostly useful for debug
+     * @param {number} index
+     * @returns {undefined|NodeProxy}
+     */
+    findNodeByPrimitive(index: number): undefined | NodeProxy;
+    /**
+     * Heuristic score of how good the tree is
+     * Lower = better
+     * @return {number}
+     */
+    area_score(): number;
+    isNodeProxy: boolean;
+}
+import { TriangleCluster } from "./TriangleCluster.js";
+//# sourceMappingURL=NodeProxy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeProxy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/NodeProxy.js"],"names":[],"mappings":"AAQA;IAEI;;;OAGG;IACH,YAFU,eAAe,EAAE,CAEZ;IAEf,4BAAiC;IACjC,6BAAyB;IAEzB;;;OAGG;IACH,UAFU,SAAS,EAAE,CAER;IAEb,qBAGE;IAEF,eAAU;IAEV,sBAcC;IAED,wBAAoB;IAEpB;;;;OAIG;IACH,oCAHW,SAAS,GACP,MAAM,CAYlB;IAED,oEAMC;IAED;;;OAGG;IACH,8BAEC;IAED,+BAcC;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAsDnB;IAED,0BAOC;IAED;;OAEG;IACH,8DAaC;IAED;;;;;;OAMG;IACH,sBALW,SAAS,eACT,MAAM,EAAE,kBACR,MAAM,EAAE,GACP,OAAO,CAwElB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,SAAS,GAAC,SAAS,CAqB/B;IAED;;;;OAIG;IACH,cAFY,MAAM,CAUjB;IAGL,qBAA+B;CAF9B;gCA3S+B,sBAAsB"}