@woosh/meep-engine 2.33.23 → 2.33.27

package/core/binary/ValidatingBitSetWrapper.js

@@ -0,0 +1,81 @@
+//
+
+/**
+ * Debug tool to verify correct behavior of a BitSet
+ */
+export class ValidatingBitSetWrapper {
+    /**
+     *
+     * @param {BitSet} source
+     */
+    constructor(source) {
+        this.__source = source;
+    }
+
+    preventShrink() {
+        this.__source.preventShrink();
+    }
+
+    setShrinkFactor(x) {
+        this.__source.setShrinkFactor(x);
+    }
+
+    setCapacity(x) {
+        this.__source.setCapacity(x);
+    }
+
+    size() {
+        return this.__source.size();
+    }
+
+    capacity() {
+        return this.__source.capacity();
+    }
+
+    previousSetBit(i) {
+        const bit = this.__source.previousSetBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== true || bit > i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    nextSetBit(i) {
+        const bit = this.__source.nextSetBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== true || bit < i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    nextClearBit(i) {
+        const bit = this.__source.nextClearBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== false || bit < i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    set(x, y) {
+        this.__source.set(x, y);
+    }
+
+    clear(i) {
+        this.__source.clear(i);
+    }
+
+    get(i) {
+        return this.__source.get(i);
+    }
+
+
+    reset() {
+        this.__source.reset();
+    }
+}

package/core/bvh2/BinaryNode.js

@@ -657,7 +657,7 @@ BinaryNode.prototype.insertManyBoxes2 = function (leafFactory, numNodes) {
     }
 
     //sort leaves
-    arrayQuickSort(nodes, n => n.computeMortonCode(), 0, max2(0, numNodes - 1));
+    arrayQuickSort(nodes, n => n.computeMortonCode(), null, 0, max2(0, numNodes - 1));
 
     let remaining_nodes = numNodes;
 

package/core/bvh2/aabb3/AABB3.js

@@ -761,16 +761,9 @@ AABB3.prototype.computePlaneSide = function computePlaneSide(plane) {
     const normal = plane.normal;
 
     return computeAABB3PlaneSide(
-        normal.x,
-        normal.y,
-        normal.z,
-        plane.constant,
-        this.x0,
-        this.y0,
-        this.z0,
-        this.x1,
-        this.y1,
-        this.z1
+        normal.x, normal.y, normal.z, plane.constant,
+        this.x0, this.y0, this.z0,
+        this.x1, this.y1, this.z1
     );
 };
 
@@ -870,6 +863,20 @@ AABB3.prototype.intersectFrustum = function intersectFrustum(frustum) {
     return true;
 };
 
+/**
+ *
+ * @param {number} v
+ */
+AABB3.prototype.grow = function (v) {
+    this.x0 -= v;
+    this.y0 -= v;
+    this.z0 -= v;
+
+    this.x1 += v;
+    this.y1 += v;
+    this.z1 += v;
+};
+
 /**
  *
  * @returns {AABB3}
@@ -882,6 +889,10 @@ AABB3.prototype.clone = function () {
     return clone;
 };
 
+AABB3.prototype.fromJSON = function ({ x0, y0, z0, x1, y1, z1 }) {
+    this.setBounds(x0, y0, z0, x1, y1, z1);
+};
+
 /**
  *
  * @param {BinaryBuffer} buffer

package/core/bvh2/aabb3/AABB3Math.js

@@ -3,9 +3,9 @@
  */
 
 
-import { intersects1D } from "../../math/MathUtils.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
+import { intersects1D } from "../../math/intersects1D.js";
 
 /**
  * Float ABS, from standard C lib

package/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -0,0 +1,498 @@
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { min2 } from "../../../math/min2.js";
+import { max2 } from "../../../math/max2.js";
+import { ceilPowerOfTwo } from "../../../binary/operations/ceilPowerOfTwo.js";
+import { array_swap } from "../../../collection/array/array_swap.js";
+import { _boxSurfaceArea2 } from "../../aabb3/AABB3Math.js";
+import { mortonEncode_magicbits } from "../../../geom/3d/morton/mortonEncode_magicbits.js";
+import { min3 } from "../../../math/min3.js";
+import { max3 } from "../../../math/max3.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+export const BVH_BOX_BYTE_SIZE = 24;
+
+/**
+ * In bytes
+ * @readonly
+ * @type {number}
+ */
+export const BVH_BINARY_NODE_SIZE = 24;
+/**
+ * @readonly
+ * @type {number}
+ */
+export const BVH_LEAF_NODE_SIZE = 28;
+
+/**
+ *
+ * @param {DataView} data
+ * @param {number} destination
+ * @param {number} source_a
+ * @param {number} source_b
+ */
+function refit_binary(data, destination, source_a, source_b) {
+    const ax0 = data.getFloat32(source_a);
+    const ay0 = data.getFloat32(source_a + 4);
+    const az0 = data.getFloat32(source_a + 8);
+    const ax1 = data.getFloat32(source_a + 12);
+    const ay1 = data.getFloat32(source_a + 16);
+    const az1 = data.getFloat32(source_a + 20);
+
+    const bx0 = data.getFloat32(source_b);
+    const by0 = data.getFloat32(source_b + 4);
+    const bz0 = data.getFloat32(source_b + 8);
+    const bx1 = data.getFloat32(source_b + 12);
+    const by1 = data.getFloat32(source_b + 16);
+    const bz1 = data.getFloat32(source_b + 20);
+
+    const x0 = min2(ax0, bx0);
+    const y0 = min2(ay0, by0);
+    const z0 = min2(az0, bz0);
+
+    const x1 = max2(ax1, bx1);
+    const y1 = max2(ay1, by1);
+    const z1 = max2(az1, bz1);
+
+    data.setFloat32(destination, x0);
+    data.setFloat32(destination + 4, y0);
+    data.setFloat32(destination + 8, z0);
+    data.setFloat32(destination + 12, x1);
+    data.setFloat32(destination + 16, y1);
+    data.setFloat32(destination + 20, z1);
+}
+
+/**
+ *
+ * @param {Uint8Array} data
+ * @param {number} destination
+ * @param {number} source
+ */
+function copy_box(data, destination, source) {
+    array_copy(data, source, data, destination, 24);
+}
+
+/**
+ *
+ * @param {DataView} data
+ * @param {number} destination
+ * @param {number} source
+ */
+function copy_box_zero_size(data, destination, source) {
+    const x = data.getFloat32(source);
+    const y = data.getFloat32(source + 4);
+    const z = data.getFloat32(source + 8);
+
+    data.setFloat32(destination, x);
+    data.setFloat32(destination + 4, y);
+    data.setFloat32(destination + 8, z);
+
+    data.setFloat32(destination + 12, x);
+    data.setFloat32(destination + 16, y);
+    data.setFloat32(destination + 20, z);
+}
+
+/**
+ * Assumes data will be normalized to 0...1 value range
+ * @param {DataView} data
+ * @param {number} address
+ * @param {number[]} matrix
+ * @returns {number}
+ */
+function build_morton(data, address, matrix) {
+
+    const x0 = data.getFloat32(address);
+    const y0 = data.getFloat32(address + 4);
+    const z0 = data.getFloat32(address + 8);
+    const x1 = data.getFloat32(address + 12);
+    const y1 = data.getFloat32(address + 16);
+    const z1 = data.getFloat32(address + 20);
+
+    const cx = (x0 + x1) / 2;
+    const cy = (y0 + y1) / 2;
+    const cz = (z0 + z1) / 2;
+
+    return mortonEncode_magicbits(cx, cy, cz);
+    // return v3_morton_encode_transformed(cx, cy, cz, matrix);
+
+}
+
+const scratch_box_0 = [];
+const scratch_box_1 = [];
+const scratch_box_2 = [];
+
+const stack = [];
+
+export class BinaryUint32BVH {
+    constructor() {
+        this.__data_buffer = new ArrayBuffer(320);
+        this.__data_uint8 = new Uint8Array(this.__data_buffer);
+
+        /**
+         * @readonly
+         * @type {DataView}
+         * @private
+         */
+        this.__data_view = new DataView(this.__data_buffer);
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__node_count_binary = 0;
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__node_count_leaf = 0;
+    }
+
+    getTotalBoxCount() {
+        return this.__node_count_binary + this.__node_count_leaf;
+    }
+
+    getBinaryNodeCount() {
+        return this.__node_count_binary;
+    }
+
+    getLeafNodeCount() {
+        return this.__node_count_leaf;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getLeafBlockAddress() {
+        return this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+    }
+
+    /**
+     *
+     * @returns {DataView}
+     */
+    getDataView() {
+        return this.__data_view;
+    }
+
+    initialize_structure() {
+        // compute memory requirements
+        const storage_size = this.__node_count_binary * BVH_BINARY_NODE_SIZE + this.__node_count_leaf * BVH_LEAF_NODE_SIZE;
+
+        // possibly resize the storage
+        if (this.__data_buffer.byteLength < storage_size) {
+            this.__data_buffer = new ArrayBuffer(storage_size);
+            this.__data_uint8 = new Uint8Array(this.__data_buffer);
+            this.__data_view = new DataView(this.__data_buffer);
+        }
+    }
+
+    /**
+     *
+     * @param {number} count
+     */
+    setLeafCount(count) {
+        this.__node_count_leaf = count;
+
+        const twoLeafLimit = ceilPowerOfTwo(count);
+
+        this.__node_count_binary = twoLeafLimit - 1;
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number} payload
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     */
+    setLeafData(index, payload, x0, y0, z0, x1, y1, z1) {
+        const address = index * BVH_LEAF_NODE_SIZE + this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+
+        const view = this.__data_view;
+
+        view.setFloat32(address, x0);
+        view.setFloat32(address + 4, y0);
+        view.setFloat32(address + 8, z0);
+        view.setFloat32(address + 12, x1);
+        view.setFloat32(address + 16, y1);
+        view.setFloat32(address + 20, z1);
+
+        view.setUint32(address + 24, payload);
+    }
+
+    /**
+     * Read bounds of a box at the given address
+     * @param {number} address where the box is found
+     * @param {number[]|Float32Array} destination where to write the box coordinates (x0,y0,z0,x1,y1,z1)
+     * @param {number} destination_offset offset within the destination array where to start writing results
+     */
+    readBounds(address, destination, destination_offset) {
+        const v = this.__data_view;
+        for (let i = 0; i < 6; i++) {
+            destination[destination_offset + i] = v.getFloat32(address + i * 4);
+        }
+    }
+
+    /**
+     *
+     * @param {number} leaf_index
+     * @returns {number}
+     */
+    readLeafPayload(leaf_index) {
+        const block_address = this.getLeafBlockAddress();
+
+        const address = block_address + leaf_index * BVH_LEAF_NODE_SIZE + BVH_BOX_BYTE_SIZE;
+
+        return this.__data_view.getUint32(address);
+    }
+
+    compute_total_surface_area() {
+        let result = 0;
+
+        const box = new Float32Array(6);
+
+        for (let i = 0; i < this.getTotalBoxCount(); i++) {
+            let address;
+
+            if (i < this.__node_count_binary) {
+                address = i * BVH_BINARY_NODE_SIZE;
+            } else {
+                const li = i - this.__node_count_binary;
+                address = li * BVH_LEAF_NODE_SIZE + this.getLeafBlockAddress();
+            }
+
+            this.readBounds(address, box, 0);
+            result += _boxSurfaceArea2(box[0], box[1], box[2], box[3], box[4], box[5]);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} a address
+     * @param {number} b address
+     * @param {number} c address
+     * @returns {number}
+     * @private
+     */
+    __compute_bounds_area_of_3_boxes(a, b, c) {
+        this.readBounds(a, scratch_box_0, 0);
+        this.readBounds(b, scratch_box_1, 0);
+        this.readBounds(c, scratch_box_2, 0);
+
+        const x0 = min3(scratch_box_0[0], scratch_box_1[0], scratch_box_2[0]);
+        const y0 = min3(scratch_box_0[1], scratch_box_1[1], scratch_box_2[1]);
+        const z0 = min3(scratch_box_0[2], scratch_box_1[2], scratch_box_2[2]);
+
+        const x1 = max3(scratch_box_0[3], scratch_box_1[3], scratch_box_2[3]);
+        const y1 = max3(scratch_box_0[4], scratch_box_1[4], scratch_box_2[4]);
+        const z1 = max3(scratch_box_0[5], scratch_box_1[5], scratch_box_2[5]);
+
+        return _boxSurfaceArea2(x0, y0, z0, x1, y1, z1);
+    }
+
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     * @returns {number}
+     * @private
+     */
+    __fitness_function_should_swap_leaves_sah(a, b) {
+        const a_0 = max2(a - 1, 0);
+        const a_1 = min2(a + 1, this.__node_count_leaf - 1);
+
+        const leaf_block_offset = this.getLeafBlockAddress();
+
+        const a_c_address = a * BVH_LEAF_NODE_SIZE + leaf_block_offset;
+        const a_0_address = a_0 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
+        const a_1_address = a_1 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
+
+
+        const b_0 = max2(b - 1, 0);
+        const b_1 = min2(b + 1, this.__node_count_leaf - 1);
+
+        const b_c_address = b * BVH_LEAF_NODE_SIZE + leaf_block_offset;
+        const b_0_address = b_0 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
+        const b_1_address = b_1 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
+
+
+        const current_area = this.__compute_bounds_area_of_3_boxes(a_0_address, a_c_address, a_1_address) + this.__compute_bounds_area_of_3_boxes(b_0_address, b_c_address, b_1_address);
+        const swap_area = this.__compute_bounds_area_of_3_boxes(a_0_address, b_c_address, a_1_address) + this.__compute_bounds_area_of_3_boxes(b_0_address, a_c_address, b_1_address);
+
+        return current_area - swap_area;
+    }
+
+    sort_bubble_sah() {
+        const n = this.__node_count_leaf;
+
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (this.__fitness_function_should_swap_leaves_sah(i, j) > 0) {
+                    this.__swap_leaves(i, j);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Sort leaf nodes according to their morton codes
+     * @param {number[]} projection
+     */
+    sort_morton(projection) {
+
+        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+
+        if (this.__node_count_leaf < 2) {
+            // no swaps available
+            return;
+        }
+
+        let stackPointer = 2;
+        let i, j;
+
+        stack[0] = 0; // first node
+        stack[1] = this.__node_count_leaf - 1; // last node
+
+        const data = this.__data_view;
+
+        while (stackPointer > 0) {
+            stackPointer -= 2;
+
+            const right = stack[stackPointer + 1];
+            const left = stack[stackPointer];
+
+            i = left;
+            j = right;
+
+            const pivotIndex = (left + right) >> 1;
+
+            const pivot = build_morton(data, pivotIndex * BVH_LEAF_NODE_SIZE + leaf_block_address, projection);
+
+            /* partition */
+            while (i <= j) {
+                while (build_morton(data, i * BVH_LEAF_NODE_SIZE + leaf_block_address, projection) < pivot) {
+                    i++;
+                }
+
+                while (build_morton(data, j * BVH_LEAF_NODE_SIZE + leaf_block_address, projection) > pivot) {
+                    j--;
+                }
+
+                if (i <= j) {
+
+                    if (i !== j) {
+                        //do swap
+                        this.__swap_leaves(i, j);
+                    }
+
+                    i++;
+                    j--;
+                }
+            }
+
+            /* recursion */
+            if (left < j) {
+                stack[stackPointer++] = left;
+                stack[stackPointer++] = j;
+            }
+            if (i < right) {
+                stack[stackPointer++] = i;
+                stack[stackPointer++] = right;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} i
+     * @param {number} j
+     * @private
+     */
+    __swap_leaves(i, j) {
+        const leaf_block_address = this.getLeafBlockAddress();
+        array_swap(
+            this.__data_uint8, i * BVH_LEAF_NODE_SIZE + leaf_block_address,
+            this.__data_uint8, j * BVH_LEAF_NODE_SIZE + leaf_block_address,
+            BVH_LEAF_NODE_SIZE
+        );
+    }
+
+    /**
+     * Assemble leaf nodes into hierarchy, set binary node bounds iteratively bottom up
+     */
+    build() {
+        const nodeCount = this.__node_count_binary;
+
+        const leaf_node_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+
+        let level = Math.floor(Math.log(nodeCount) / Math.log(2));
+
+        let i, offset, level_node_count;
+        //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node
+        //build one level above leaf nodes
+        level_node_count = Math.pow(2, level);
+        offset = (level_node_count - 1) * BVH_BINARY_NODE_SIZE;
+
+        let parentIndex;
+
+        const node_count_leaf = this.__node_count_leaf;
+
+        // build bottom-most level, just above the leaves
+        for (i = 0; i < level_node_count; i++) {
+            const leafIndex0 = i * 2;
+            const leafIndex1 = leafIndex0 + 1;
+
+            const leafOffset0 = leaf_node_block_address + leafIndex0 * BVH_LEAF_NODE_SIZE;
+            const leafOffset1 = leaf_node_block_address + leafIndex1 * BVH_LEAF_NODE_SIZE;
+
+            if (leafIndex1 < node_count_leaf) {
+                // both children nodes are valid
+                refit_binary(this.__data_view, offset, leafOffset0, leafOffset1);
+            } else if (leafIndex0 < node_count_leaf) {
+                // only left child node is valid
+                copy_box(this.__data_uint8, offset, leafOffset0);
+            } else {
+                //initialize to 0-size box same position as previous node
+                copy_box_zero_size(this.__data_view, offset, offset - BVH_BINARY_NODE_SIZE);
+            }
+
+            offset += BVH_BINARY_NODE_SIZE;
+        }
+
+        level--;
+
+        //build intermediate nodes
+        for (; level >= 0; level--) {
+            level_node_count = Math.pow(2, level);
+            parentIndex = (level_node_count - 1);
+
+            for (i = 0; i < level_node_count; i++) {
+
+                const childIndex0 = (parentIndex << 1) + 1;
+                const childIndex1 = childIndex0 + 1;
+
+                const address_parent = parentIndex * BVH_BINARY_NODE_SIZE;
+
+                const address_child_0 = childIndex0 * BVH_BINARY_NODE_SIZE;
+                const address_child_1 = childIndex1 * BVH_BINARY_NODE_SIZE;
+
+                refit_binary(this.__data_view, address_parent, address_child_0, address_child_1);
+
+                parentIndex++;
+            }
+        }
+    }
+}

package/core/bvh2/binary/2/BinaryUint32BVH.spec.js

@@ -0,0 +1,54 @@
+import { BinaryUint32BVH } from "./BinaryUint32BVH.js";
+
+test('constructor does not throw', () => {
+    new BinaryUint32BVH();
+});
+
+test('1 leaf build does not throw', () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(1);
+    bvh.initialize_structure();
+    bvh.build();
+});
+
+test('read/write 1 leaf', () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(1);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 7, -3, -7, -11, 13, 17, 23);
+
+    expect(bvh.readLeafPayload(0)).toBe(7);
+
+    const bounds = [];
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds[0]).toBeCloseTo(-3);
+    expect(bounds[1]).toBeCloseTo(-7);
+    expect(bounds[2]).toBeCloseTo(-11);
+    expect(bounds[3]).toBeCloseTo(13);
+    expect(bounds[4]).toBeCloseTo(17);
+    expect(bounds[5]).toBeCloseTo(23);
+});
+
+test('4 node sorted build', () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(4);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
+    bvh.setLeafData(2, 11, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6);
+    bvh.setLeafData(3, 13, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6);
+
+    bvh.sort_morton([
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        0, 0, 0, 1
+    ]);
+    bvh.build();
+});