@woosh/meep-engine 2.74.0 → 2.75.1

package/src/core/bvh2/bvh3/BVH.js

@@ -1,4 +1,5 @@
 import { assert } from "../../assert.js";
+import { UINT32_MAX } from "../../binary/UINT32_MAX.js";
 import { array_copy } from "../../collection/array/array_copy.js";
 import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
 import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
@@ -51,6 +52,13 @@ export const ELEMENT_WORD_COUNT = 10;
  */
 const INITIAL_CAPACITY = 128;
 
+
+/**
+ * Tree can not contain more than this number of nodes
+ * @type {number}
+ */
+const NODE_CAPACITY_LIMIT = Math.floor(UINT32_MAX / (ELEMENT_WORD_COUNT * 4));
+
 /**
  * Bounding Volume Hierarchy implementation. Stores unsigned integer values at leaves, these are typically IDs or Index values.
  * Highly optimized both in terms of memory usage and CPU. Most of the code inlined. No allocation are performed during usage (except for growing the tree capacity).
@@ -145,17 +153,26 @@ export class BVH {
     }
 
     __grow_capacity() {
-        const new_capacity = Math.ceil(max2(
+        if (this.__capacity >= NODE_CAPACITY_LIMIT) {
+            throw new Error('Can not grow capacity, already at maximum platform limit');
+        }
+
+        let new_capacity = Math.ceil(max2(
             this.__capacity * CAPACITY_GROW_MULTIPLIER,
             this.__capacity + CAPACITY_GROW_MIN_STEP
         ));
 
+        if (new_capacity > NODE_CAPACITY_LIMIT) {
+            // can not grow as much as we'd like, but we can still grow up to the limit
+            new_capacity = NODE_CAPACITY_LIMIT;
+        }
+
         this.__set_capacity(new_capacity);
     }
 
     /**
      *
-     * @param {number} new_capacity
+     * @param {number} new_capacity in number of nodes
      * @private
      */
     __set_capacity(new_capacity) {
@@ -707,6 +724,9 @@ export class BVH {
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
+            assert.notEqual(child1, index, 'child1 is equal to parent');
+            assert.notEqual(child2, index, 'child2 is equal to parent');
+
             this.node_set_combined_aabb(index, child1, child2);
 
             index = uint32[address + COLUMN_PARENT];
@@ -734,6 +754,9 @@ export class BVH {
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
+            assert.notEqual(child1, index, 'child1 is equal to parent');
+            assert.notEqual(child2, index, 'child2 is equal to parent');
+
             uint32[node_address + COLUMN_HEIGHT] = 1 + max2(
                 uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
                 uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
@@ -815,6 +838,9 @@ export class BVH {
         const iB = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
         const iC = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
+        assert.notEqual(iA, iB, 'child1 equal to parent');
+        assert.notEqual(iA, iB, 'child2 equal to parent');
+
         assert.greaterThanOrEqual(iB, 0);
         assert.lessThan(iB, this.node_capacity);
         assert.greaterThanOrEqual(iC, 0);
@@ -830,6 +856,9 @@ export class BVH {
             const iF = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
             const iG = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
+            assert.notEqual(iC, iF, 'child1 equal to parent');
+            assert.notEqual(iC, iG, 'child2 equal to parent');
+
             // b2TreeNode* F = m_nodes + iF;
             // b2TreeNode* G = m_nodes + iG;
 
@@ -848,6 +877,7 @@ export class BVH {
 
             // A's old parent should point to C
             if (a_parent !== NULL_NODE) {
+                assert.notEqual(a_parent, iC);
                 if (uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === iA) {
                     uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iC;
                 } else {
@@ -900,6 +930,9 @@ export class BVH {
 
             }
 
+            assert.notEqual(iC, uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_1]);
+            assert.notEqual(iC, uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2]);
+
             return iC;
         }
 
@@ -908,6 +941,9 @@ export class BVH {
             const iD = uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
             const iE = uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
+            assert.notEqual(iB, iD, 'child1 equal to parent');
+            assert.notEqual(iB, iE, 'child2 equal to parent');
+
             assert.greaterThanOrEqual(iD, 0);
             assert.lessThan(iD, this.node_capacity);
             assert.greaterThanOrEqual(iE, 0);
@@ -974,9 +1010,15 @@ export class BVH {
 
             }
 
+            assert.notEqual(iB, uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_1]);
+            assert.notEqual(iB, uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2]);
+
             return iB;
         }
 
+        assert.notEqual(iA, uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1]);
+        assert.notEqual(iA, uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2]);
+
         // no rotation
         return iA;
     }

package/src/core/bvh2/bvh3/BVH.spec.js

@@ -1,3 +1,5 @@
+import { randomFloatBetween } from "../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../math/random/seededRandom.js";
 import { BVH, NULL_NODE } from "./BVH.js";
 
 test("constructor doesn't throw", () => {
@@ -302,3 +304,46 @@ test("move leaf node", () => {
 
     expect(actual_bounds).toEqual(a_new_bounds);
 });
+
+test.skip("performance, insert 10k random nodes", () => {
+
+    const random = seededRandom(1);
+
+    const bvh = new BVH();
+
+    const min_bound = -1000;
+    const max_bound = 1000;
+
+    const OBJECT_COUNT = 1000000;
+
+
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, i);
+
+        const x = randomFloatBetween(random, min_bound, max_bound);
+        const y = randomFloatBetween(random, min_bound, max_bound);
+        const z = randomFloatBetween(random, min_bound, max_bound);
+
+        const extents = randomFloatBetween(random, 1, 10);
+
+        const x0 = x - extents;
+        const y0 = y - extents;
+        const z0 = z - extents;
+
+        const x1 = x + extents;
+        const y1 = y + extents;
+        const z1 = z + extents;
+
+        // console.log([x0, y0, z0, x1, y1, z1].join(', '))
+
+        bvh.node_set_aabb_primitive(
+            node,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        bvh.insert_leaf(node);
+    }
+});

package/src/core/bvh2/bvh3/build_triangle_morton_codes.js

@@ -0,0 +1,73 @@
+import morton from "../../geom/3d/morton/Morton.js";
+
+/**
+ * Compute morton codes for each triangle
+ * @param {number[]|Uint32Array} morton_codes
+ * @param {number} tri_count
+ * @param {number[]|Uint8Array|Uint16Array|Uint32Array} index_array
+ * @param {number[]|Float32Array} position_array
+ * @param {number} aabb_x0
+ * @param {number} aabb_y0
+ * @param {number} aabb_z0
+ * @param {number} aabb_x1
+ * @param {number} aabb_y1
+ * @param {number} aabb_z1
+ */
+export function build_triangle_morton_codes(
+    morton_codes,
+    tri_count,
+    index_array,
+    position_array,
+    aabb_x0, aabb_y0, aabb_z0,
+    aabb_x1, aabb_y1, aabb_z1
+) {
+
+    const aabb_size_x = aabb_x1 - aabb_x0;
+    const aabb_size_y = aabb_y1 - aabb_y0;
+    const aabb_size_z = aabb_z1 - aabb_z0;
+
+    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;
+
+    // compute morton codes
+    for (let i = 0; i < tri_count; i++) {
+
+
+        const i3 = i * 3;
+
+        const a = index_array[i3];
+        const b = index_array[i3 + 1];
+        const c = index_array[i3 + 2];
+
+        const a_address = a * 3;
+        const ax = position_array[a_address];
+        const ay = position_array[a_address + 1];
+        const az = position_array[a_address + 2];
+
+        const b_address = b * 3;
+        const bx = position_array[b_address];
+        const by = position_array[b_address + 1];
+        const bz = position_array[b_address + 2];
+
+        const c_address = c * 3;
+        const cx = position_array[c_address];
+        const cy = position_array[c_address + 1];
+        const cz = position_array[c_address + 2];
+
+        const center_x = (ax + bx + cx) * 0.333333333;
+        const center_y = (ay + by + cy) * 0.333333333;
+        const center_z = (az + bz + cz) * 0.333333333;
+
+        // normalize to bounds
+        const ncx = (center_x - aabb_x0) * morton_scale_x;
+        const ncy = (center_y - aabb_y0) * morton_scale_y;
+        const ncz = (center_z - aabb_z0) * morton_scale_z;
+
+        morton_codes[i] = morton(
+            Math.round(ncx),
+            Math.round(ncy),
+            Math.round(ncz)
+        );
+    }
+}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -2,9 +2,10 @@ import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_
 import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
-import morton from "../../geom/3d/morton/Morton.js";
 import { max2 } from "../../math/max2.js";
+import { build_triangle_morton_codes } from "./build_triangle_morton_codes.js";
 import { NULL_NODE } from "./BVH.js";
+import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
 
 /**
  * Build the BVH bottom-up using spatial hash sorting
@@ -22,18 +23,6 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
     // get bounds for the entire geometry
     aabb3_from_v3_array(aabb3, position_array, position_array.length);
 
-    const aabb_x0 = aabb3.x0;
-    const aabb_y0 = aabb3.y0;
-    const aabb_z0 = aabb3.z0;
-
-    const aabb_size_x = aabb3.getExtentsX();
-    const aabb_size_y = aabb3.getExtentsY();
-    const aabb_size_z = aabb3.getExtentsZ();
-
-    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;
-
     // allocate nodes
     const tri_count = index_array.length / 3;
     const node_leaf_count = tri_count;
@@ -52,59 +41,15 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         nodes[i] = (node_total_count - 1) - i;
     }
 
-    // for (let i = node_total_count - 1; i >= 0; i--) {
-    //     // store nodes in reverse order so that top-level nodes end up on top
-    //     nodes[i] = bvh.allocate_node();
-    // }
-
     const morton_codes = new Uint32Array(tri_count);
     const sorted_triangle_order = new Uint32Array(tri_count);
 
-    // compute morton codes
     for (let i = 0; i < tri_count; i++) {
-
         sorted_triangle_order[i] = i;
-
-        const i3 = i * 3;
-
-        const a = index_array[i3];
-        const b = index_array[i3 + 1];
-        const c = index_array[i3 + 2];
-
-        const a_address = a * 3;
-        const ax = position_array[a_address];
-        const ay = position_array[a_address + 1];
-        const az = position_array[a_address + 2];
-
-        const b_address = b * 3;
-        const bx = position_array[b_address];
-        const by = position_array[b_address + 1];
-        const bz = position_array[b_address + 2];
-
-        const c_address = c * 3;
-        const cx = position_array[c_address];
-        const cy = position_array[c_address + 1];
-        const cz = position_array[c_address + 2];
-
-        const center_x = (ax + bx + cx) * 0.333333333;
-        const center_y = (ay + by + cy) * 0.333333333;
-        const center_z = (az + bz + cz) * 0.333333333;
-
-
-        // normalize to bounds
-        const ncx = (center_x - aabb_x0) * morton_scale_x;
-        const ncy = (center_y - aabb_y0) * morton_scale_y;
-        const ncz = (center_z - aabb_z0) * morton_scale_z;
-
-        const morton_code = morton(
-            Math.round(ncx),
-            Math.round(ncy),
-            Math.round(ncz)
-        );
-
-        morton_codes[i] = morton_code;
     }
 
+    build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, aabb3.x0, aabb3.y0, aabb3.z0, aabb3.x1, aabb3.y1, aabb3.z1);
+
     // sort leaves by morton codes
     arrayQuickSort(sorted_triangle_order, (triangle_index) => morton_codes[triangle_index], null, 0, tri_count - 1);
 
@@ -129,47 +74,6 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         unprocessed_nodes[i] = node;
     }
 
-    // Assemble hierarchy
-    let unprocessed_node_count = tri_count;
-
-
-    while (used_index < node_total_count && unprocessed_node_count > 1) {
-
-        let added_nodes = 0;
-        let cursor = 0;
-
-        while (cursor + 1 < unprocessed_node_count) {
-            const child_1 = unprocessed_nodes[cursor++];
-            const child_2 = unprocessed_nodes[cursor++];
-
-            const parent = nodes[used_index++];
-
-            bvh.node_set_combined_aabb(parent, child_1, child_2);
-
-            bvh.node_set_parent(child_1, parent);
-            bvh.node_set_parent(child_2, parent);
-
-            bvh.node_set_child1(parent, child_1);
-            bvh.node_set_child2(parent, child_2);
-
-            bvh.node_set_height(parent,
-                1 + max2(
-                    bvh.node_get_height(child_1),
-                    bvh.node_get_height(child_2)
-                )
-            );
-
-            unprocessed_nodes[added_nodes++] = parent;
-        }
-
-        while (cursor < unprocessed_node_count) {
-            // dangling nodes, push them onto the next level
-            unprocessed_nodes[added_nodes++] = unprocessed_nodes[cursor++];
-        }
-
-        unprocessed_node_count = added_nodes;
-    }
-
     // assign root
-    bvh.__root = nodes[nodes.length - 1];
+    bvh.__root = ebvh_build_hierarchy(bvh,unprocessed_nodes,tri_count,nodes,used_index);
 }

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -0,0 +1,59 @@
+import { max2 } from "../../math/max2.js";
+
+/**
+ * Assumes nodes are spatially sorted
+ * NOTE: {@link unprocessed_nodes} will be modified during execution to save memory
+ * @param {BVH} bvh
+ * @param {number[]|Uint32Array} unprocessed_nodes contains nodes that need to be built into a hierarchy, these must not be present in the BVH hierarchy
+ * @param {number} input_node_count
+ * @param {number[]|Uint32Array} node_pool Contains node indices that can be used to build ancestry hierarchy, need to be pre-allocated before calling this method
+ * @param {number} node_pool_offset
+ * @returns {number} new root
+ */
+export function ebvh_build_hierarchy(bvh, unprocessed_nodes, input_node_count, node_pool, node_pool_offset) {
+
+    let used_index = node_pool_offset;
+
+    // Assemble hierarchy
+    let unprocessed_node_count = input_node_count;
+
+
+    while (unprocessed_node_count > 1) {
+
+        let added_nodes = 0;
+        let cursor = 0;
+
+        while (cursor + 1 < unprocessed_node_count) {
+            const child_1 = unprocessed_nodes[cursor++];
+            const child_2 = unprocessed_nodes[cursor++];
+
+            const parent = node_pool[used_index++];
+
+            bvh.node_set_combined_aabb(parent, child_1, child_2);
+
+            bvh.node_set_parent(child_1, parent);
+            bvh.node_set_parent(child_2, parent);
+
+            bvh.node_set_child1(parent, child_1);
+            bvh.node_set_child2(parent, child_2);
+
+            bvh.node_set_height(parent,
+                1 + max2(
+                    bvh.node_get_height(child_1),
+                    bvh.node_get_height(child_2)
+                )
+            );
+
+            unprocessed_nodes[added_nodes++] = parent;
+        }
+
+        while (cursor < unprocessed_node_count) {
+            // dangling nodes, push them onto the next level
+            unprocessed_nodes[added_nodes++] = unprocessed_nodes[cursor++];
+        }
+
+        unprocessed_node_count = added_nodes;
+    }
+
+    return unprocessed_nodes[0];
+}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point.js

@@ -1,13 +1,6 @@
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_signed_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
-import { max2 } from "../../../math/max2.js";
-import { NULL_NODE } from "../BVH.js";
-
-/**
- *
- * @type {number[]}
- */
-const scratch_aabb = [];
+import { aabb3_unsigned_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -21,7 +14,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number} user data of the leaf, or -1 if not found
  */
 export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance = Infinity) {
-      const root = bvh.root;
+    const root = bvh.root;
 
     if (root === NULL_NODE) {
         return -1;
@@ -35,10 +28,17 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
 
     stack[stack_top] = root;
 
-    let best_leaf_data = -1;
+    let best_leaf = -1;
     let best_distance_sqr = max_distance * max_distance;
 
-    while (stack.pointer > stack_top) {
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
         stack.pointer--;
 
         /**
@@ -47,42 +47,41 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
          */
         const node = stack[stack.pointer];
 
-        bvh.node_get_aabb(node, scratch_aabb);
+        const address = node * ELEMENT_WORD_COUNT;
 
         // compute distance to box
-        const distance_sqr = max2(0, aabb3_signed_distance_sqr_to_point(
-            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
-            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
+        const distance_sqr = aabb3_unsigned_distance_sqr_to_point(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
             x, y, z
-        ));
+        );
 
-        if (distance_sqr > best_distance_sqr) {
+        if (distance_sqr >= best_distance_sqr) {
             // node is too far
             continue;
         }
 
-        const node_is_leaf = bvh.node_is_leaf(node);
-
-        if (!node_is_leaf) {
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
 
-            // read in-order
-            const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child2(node);
+        if (child_1 !== NULL_NODE) {
 
-            // write to stack in reverse order, so that fist child ends up being visited first
-            stack[stack.pointer++] = child1;
-            stack[stack.pointer++] = child2;
+            // this is not a leaf node, push children onto traversal stack
+            stack[stack.pointer++] = child_1;
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
 
         } else {
 
             // leaf node
-            if (distance_sqr < best_distance_sqr) {
-                best_distance_sqr = distance_sqr;
-                best_leaf_data = bvh.node_get_user_data(node);
-            }
+            best_distance_sqr = distance_sqr;
+            best_leaf = node;
 
         }
+    } while (stack.pointer > stack_top)
+
+    if (best_leaf === -1) {
+        return -1;
     }
 
-    return best_leaf_data;
+    return bvh.node_get_user_data(best_leaf);
 }