@woosh/meep-engine 2.43.16 → 2.43.18

package/core/assert.js

@@ -380,7 +380,9 @@ assert.notNaN = function (value, name = "value") {
  * @param {string} name
  */
 assert.isFiniteNumber = function (value, name = "value") {
-    assert.ok(Number.isFinite(value), `${name} must be a finite number, instead was ${value}`);
+    if (!Number.isFinite(value)) {
+        throw new Error(`${name} must be a finite number, instead was ${value}`);
+    }
 };
 
 export {

package/core/bvh2/aabb3/aabb3_intersects_ray.js

@@ -1,5 +1,6 @@
 import { fabsf } from "../../math/fabsf.js";
 
+
 /**
  * NOTES:
  *      https://web.archive.org/web/20090803054252/http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c
@@ -20,41 +21,46 @@ import { fabsf } from "../../math/fabsf.js";
  * @param {number} dirZ
  * @returns {boolean}
  */
-function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, dirZ) {
+export function aabb3_intersects_ray(
+    x0, y0, z0,
+    x1, y1, z1,
+    oX, oY, oZ,
+    dirX, dirY, dirZ
+) {
 
     // Z Projection
-    const boxExtentsX = (x1 - x0) / 2;
+    const boxExtentsX = (x1 - x0) * 0.5;
 
     const centerX = x0 + boxExtentsX;
 
     const diffX = oX - centerX;
 
 
-    if (fabsf(diffX) > boxExtentsX && diffX * dirX >= 0.0) {
+    if (diffX * dirX >= 0.0 && fabsf(diffX) > boxExtentsX) {
         return false;
     }
 
     // Y projection
-    const boxExtentsY = (y1 - y0) / 2;
+    const boxExtentsY = (y1 - y0) * 0.5;
 
     const centerY = y0 + boxExtentsY;
 
     const diffY = oY - centerY;
 
 
-    if (fabsf(diffY) > boxExtentsY && diffY * dirY >= 0.0) {
+    if (diffY * dirY >= 0.0 && fabsf(diffY) > boxExtentsY) {
         return false;
     }
 
     // Z projection
-    const boxExtentsZ = (z1 - z0) / 2;
+    const boxExtentsZ = (z1 - z0) * 0.5;
 
     const centerZ = z0 + boxExtentsZ;
 
     const diffZ = oZ - centerZ;
 
 
-    if (fabsf(diffZ) > boxExtentsZ && diffZ * dirZ >= 0.0) {
+    if (diffZ * dirZ >= 0.0 && fabsf(diffZ) > boxExtentsZ) {
         return false;
     }
 
@@ -64,9 +70,9 @@ function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, di
     //b = fabsf(Dir.y);
     //if(fabsf(Diff.y)>BoxExtents.y + b)	return false;
 
-    const a = fabsf(dirX);
     const b = fabsf(dirY);
     const c = fabsf(dirZ);
+    const a = fabsf(dirX);
 
     const f0 = dirY * diffZ - dirZ * diffY;
 
@@ -89,4 +95,3 @@ function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, di
     return true;
 }
 
-export { aabb3_intersects_ray };

package/core/bvh2/aabb3/aabb3_intersects_ray_branchless.js

@@ -0,0 +1,52 @@
+import { min2 } from "../../math/min2.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ * SLOW, don't use in production
+ * It is branchless on systems where min/max instructions exist.
+ * Unfortunately in JS that's not the case, so this is just a curiosity
+ * @see https://tavianator.com/2011/ray_box.html
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} oX
+ * @param {number} oY
+ * @param {number} oZ
+ * @param {number} dirX
+ * @param {number} dirY
+ * @param {number} dirZ
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_branchless(
+    x0, y0, z0,
+    x1, y1, z1,
+    oX, oY, oZ,
+    dirX, dirY, dirZ
+) {
+    const inv_dir_x = 1 / dirX;
+    const inv_dir_y = 1 / dirY;
+    const inv_dir_z = 1 / dirZ;
+
+    const tx1 = (x0 - oX) * inv_dir_x;
+    const tx2 = (x1 - oX) * inv_dir_x;
+
+    let tmin = min2(tx1, tx2);
+    let tmax = max2(tx1, tx2);
+
+    const ty1 = (y0 - oY) * inv_dir_y;
+    const ty2 = (y1 - oY) * inv_dir_y;
+
+    tmin = max2(tmin, min2(ty1, ty2));
+    tmax = min2(tmax, max2(ty1, ty2));
+
+    const tz1 = (z0 - oZ) * inv_dir_z;
+    const tz2 = (z1 - oZ) * inv_dir_z;
+
+    tmin = max2(tmin, min2(tz1, tz2));
+    tmax = min2(tmax, max2(tz1, tz2));
+
+    return tmax >= tmin;
+}

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.d.ts

@@ -20,4 +20,6 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_get_user_data(node: number): number
 
     release_all(): void
+
+    trim(): void
 }

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -2,10 +2,12 @@ import { aabb3_compute_surface_area } from "../aabb3/aabb3_compute_surface_area.
 import { min2 } from "../../math/min2.js";
 import { max2 } from "../../math/max2.js";
 import { assert } from "../../assert.js";
+import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
+import { array_copy } from "../../collection/array/copyArray.js";
 
 const COLUMN_PARENT = 6;
-const COLUMN_CHILD_1 = 7;
-const COLUMN_CHILD_2 = 8;
+export const COLUMN_CHILD_1 = 7;
+export const COLUMN_CHILD_2 = 8;
 const COLUMN_HEIGHT = 9;
 
 /**
@@ -40,7 +42,7 @@ const CAPACITY_GROW_MIN_STEP = 64;
  * @readonly
  * @type {number}
  */
-const ELEMENT_WORD_COUNT = 10;
+export const ELEMENT_WORD_COUNT = 10;
 
 /**
  * How many nodes can be stored in the newly constructed tree before allocation needs to take place
@@ -134,6 +136,16 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             this.__capacity + CAPACITY_GROW_MIN_STEP
         ));
 
+        this.__set_capacity(new_capacity);
+    }
+
+    /**
+     *
+     * @param {number} new_capacity
+     * @private
+     */
+    __set_capacity(new_capacity) {
+
         const old_data_uint32 = this.__data_uint32;
 
         const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_WORD_COUNT * 4);
@@ -144,11 +156,20 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         this.__data_uint32 = new Uint32Array(new_data_buffer);
 
         // copy old data into new buffer
-        this.__data_uint32.set(old_data_uint32);
+        typed_array_copy(old_data_uint32, this.__data_uint32);
 
         this.__capacity = new_capacity;
     }
 
+    /**
+     * Trim allocated memory region to only contain allocated nodes
+     */
+    trim() {
+        if (this.__capacity > this.__size) {
+            this.__set_capacity(this.__size);
+        }
+    }
+
     /**
      *
      * @returns {number}
@@ -945,11 +966,199 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return i - destination_offset;
     }
 
+    /**
+     * Update parent and child links of a given node to point to a new location, useful for re-locating nodes
+     * @param {number} node node to update
+     * @param {number} destination Where updated links should point to
+     * @private
+     */
+    __move_node_links(node, destination) {
+
+        const uint32 = this.__data_uint32;
+
+        const source_address = node * ELEMENT_WORD_COUNT;
+
+        // update children of a
+        const child1 = uint32[source_address + COLUMN_CHILD_1];
+        const child2 = uint32[source_address + COLUMN_CHILD_2];
+
+        if (child1 !== NULL_NODE) {
+
+            uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_PARENT] = destination;
+            uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_PARENT] = destination;
+
+        }
+
+        // update parent of a
+        const parent = uint32[source_address + COLUMN_PARENT];
+
+        if (parent !== NULL_NODE) {
+            const parent_child1 = uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+
+            if (parent_child1 === node) {
+                uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = destination;
+            } else {
+                uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = destination;
+            }
+        }
+    }
+
+    /**
+     * Swap two nodes in memory
+     * @param {number} a
+     * @param {number} b
+     * @returns {boolean}
+     */
+    swap_nodes(a, b) {
+        // console.log(`swap ${a} - ${b}`)
+
+        const uint32 = this.__data_uint32;
+
+        const address_a = a * ELEMENT_WORD_COUNT;
+        const address_b = b * ELEMENT_WORD_COUNT;
+
+
+        if (uint32[address_a + COLUMN_PARENT] === b) {
+            // attempting to swap direct parent/child, this is unsupported
+            return false;
+        }
+        if (uint32[address_b + COLUMN_PARENT] === a) {
+            // attempting to swap direct parent/child, this is unsupported
+            return false;
+        }
+
+        this.__move_node_links(a, b);
+        this.__move_node_links(b, a);
+
+        // copy A to temp buffer
+        array_copy(uint32, address_a, this.__free, this.__free_pointer, ELEMENT_WORD_COUNT);
+
+        // write data
+        array_copy(uint32, address_b, uint32, address_a, ELEMENT_WORD_COUNT);
+        array_copy(this.__free, this.__free_pointer, uint32, address_b, ELEMENT_WORD_COUNT);
+
+        // update root as necessary
+        if (this.__root === a) {
+            this.__root = b;
+        } else if (this.__root === b) {
+            this.__root = a;
+        }
+
+        return true;
+    }
+
+
     /**
      * Sort live nodes in the traversal order.
      * This makes most queries have linear access, resulting in near-optimal cache usage
+     * NOTE: assumes that there are no free nodes
      */
     sort_for_traversal_depth_first() {
-        throw new Error('Not Implemented');
+        const stack = [];
+
+        stack[0] = 0;
+        stack[1] = this.__size - 1;
+
+        let stack_pointer = 2;
+        let i, j;
+
+        const uint32 = this.__data_uint32;
+        const float32 = this.__data_float32;
+
+        while (stack_pointer > 0) {
+            stack_pointer -= 2;
+
+            const right = stack[stack_pointer + 1];
+            const left = stack[stack_pointer];
+
+            i = left;
+            j = right;
+
+            const pivotIndex = (left + right) >> 1;
+
+            /* partition */
+            while (i <= j) {
+
+                while (traversal_sort_compare_nodes(uint32, float32, i, pivotIndex) > 0) {
+                    i++;
+                }
+
+                while (traversal_sort_compare_nodes(uint32, float32, j, pivotIndex) < 0) {
+                    j--;
+                }
+
+                if (i <= j) {
+
+                    if (i !== j) {
+                        //do swap
+                        this.swap_nodes(i, j);
+                    }
+
+                    i++;
+                    j--;
+                }
+            }
+
+            /* recursion */
+            if (left < j) {
+                stack[stack_pointer++] = left;
+                stack[stack_pointer++] = j;
+            }
+            if (i < right) {
+                stack[stack_pointer++] = i;
+                stack[stack_pointer++] = right;
+            }
+        }
     }
 }
+
+/**
+ *
+ * @param {Uint32Array} uint32
+ * @param {number} node_index
+ * @return {number}
+ */
+function compute_traversal_index_upper_bound(uint32, node_index) {
+    let n = node_index;
+
+    let parent = uint32[node_index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+
+    let result = 0;
+    let x = 0;
+
+    while (parent !== NULL_NODE) {
+
+        if (uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === n) {
+            result += Math.pow(2, x);
+        }
+
+        x++;
+
+        n = parent;
+        parent = uint32[n * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {Uint32Array} uint32
+ * @param {Float32Array} float32
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function traversal_sort_compare_nodes(uint32, float32, a, b) {
+    const a_height = uint32[a * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
+    const b_height = uint32[b * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
+
+    const height_delta = a_height - b_height;
+
+    if (height_delta !== 0) {
+        return height_delta;
+    }
+
+    return compute_traversal_index_upper_bound(uint32, a) - compute_traversal_index_upper_bound(uint32, b);
+
+}

package/core/bvh2/bvh3/bvh_query_leaves_ray.js

@@ -1,23 +1,16 @@
 import { aabb3_intersects_ray } from "../aabb3/aabb3_intersects_ray.js";
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import {
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "./ExplicitBinaryBoundingVolumeHierarchy.js";
 
 /**
  *
  * @type {number[]}
  */
-const traversal_stack = [];
-
-/**
- *
- * @type {number[]}
- */
-const scratch_aabb = [];
-
-/**
- *
- * @type {number}
- */
-let traversal_cursor = 0;
+const traversal_stack = new Uint32Array(2048);
 
 
 /**
@@ -39,19 +32,29 @@ export function bvh_query_leaves_ray(
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z
 ) {
-    const stack_frame_address = traversal_cursor;
-
     const root = bvh.root;
 
     if (root === NULL_NODE) {
         return 0;
     }
 
-    traversal_stack[traversal_cursor++] = root;
 
-    let result_cursor = result_offset;
+    traversal_stack[0] = root;
 
-    while (traversal_cursor > stack_frame_address) {
+    let result_cursor = result_offset;
+    /**
+     *
+     * @type {number}
+     */
+    let traversal_cursor = 1;
+
+    /*
+     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 {
         traversal_cursor--;
 
         /**
@@ -60,12 +63,12 @@ export function bvh_query_leaves_ray(
          */
         const node = traversal_stack[traversal_cursor];
 
-        bvh.node_get_aabb(node, scratch_aabb);
+        const address = node * ELEMENT_WORD_COUNT;
 
         // test node against the ray
         const intersects = aabb3_intersects_ray(
-            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
-            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z
         );
@@ -74,22 +77,22 @@ export function bvh_query_leaves_ray(
             continue;
         }
 
-        const node_is_leaf = bvh.node_is_leaf(node);
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
 
-        if (!node_is_leaf) {
+        if (child_1 !== NULL_NODE) {
 
-            traversal_stack[traversal_cursor++] = bvh.node_get_child1(node);
-            traversal_stack[traversal_cursor++] = bvh.node_get_child2(node);
+            // this is not a leaf node, push children onto traversal stack
+            traversal_stack[traversal_cursor++] = child_1;
+            traversal_stack[traversal_cursor++] = uint32[address + COLUMN_CHILD_2];
 
         } else {
             // leaf node
 
             result[result_cursor++] = node;
         }
-    }
+    } while (traversal_cursor > 0);
 
     // drop stack frame
-    traversal_cursor = stack_frame_address;
-
     return result_cursor - result_offset;
 }

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  * Assumes arrays have the same type
- * @param {TypedArray|Float32Array|Uint8Array} source
- * @param {TypedArray|Float32Array|Uint8Array} destination
+ * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} source
+ * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/geom/3d/aabb/compute_aabb_from_points.js

@@ -4,11 +4,12 @@ import { max2 } from "../../../math/max2.js";
 /**
  * Multidimensional axis-aligned bounding box calculation
  * @param {number[]} result
- * @param {number[]} input
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_offset
  * @param {number} input_count
  * @param {number} d number of dimensions
  */
-export function compute_aabb_from_points(result, input, input_count, d) {
+export function compute_aabb_from_points(result, input, input_offset, input_count, d) {
     let i = 0;
     let j = 0;
 
@@ -19,7 +20,7 @@ export function compute_aabb_from_points(result, input, input_count, d) {
 
     for (i = 0; i < input_count; i++) {
         for (j = 0; j < d; j++) {
-            const v = input[i*d + j];
+            const v = input[input_count + i * d + j];
 
             result[j] = min2(result[j], v);
             result[j + d] = max2(result[j + d], v);

package/core/geom/3d/compute_triangle_normal.js

@@ -0,0 +1,76 @@
+import { v3_length_sqr } from "../v3_length_sqr.js";
+import { vec3 } from "gl-matrix";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} vAx
+ * @param {number} vAy
+ * @param {number} vAz
+ * @param {number} vBx
+ * @param {number} vBy
+ * @param {number} vBz
+ * @param {number} vCx
+ * @param {number} vCy
+ * @param {number} vCz
+ */
+export function v3_compute_triangle_normal(result, result_offset, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz) {
+    //compute CB and AB vectors
+    const vCBx = vCx - vBx;
+    const vCBy = vCy - vBy;
+    const vCBz = vCz - vBz;
+
+    const vABx = vAx - vBx;
+    const vABy = vAy - vBy;
+    const vABz = vAz - vBz;
+
+    //compute triangle normal
+    const crossX = vCBy * vABz - vCBz * vABy;
+    const crossY = vCBz * vABx - vCBx * vABz;
+    const crossZ = vCBx * vABy - vCBy * vABx;
+
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
+
+    if (l_sqr === 0) {
+        // degenerate triangle, provide arbitrary invalid result
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1;
+        result[result_offset + 2] = 0;
+        return;
+    }
+
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}
+
+/**
+ *
+ * @param {number[]|vec3} result
+ * @param {number[]} vA
+ * @param {number[]} vB
+ * @param {number[]} vC
+ */
+export function compute_triangle_normal(result, vA, vB, vC) {
+
+    const vAx = vA[0];
+    const vAy = vA[1];
+    const vAz = vA[2];
+
+    const vBx = vB[0];
+    const vBy = vB[1];
+    const vBz = vB[2];
+
+    const vCx = vC[0];
+    const vCy = vC[1];
+    const vCz = vC[2];
+
+    v3_compute_triangle_normal(result, 0, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz);
+}

package/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -211,7 +211,7 @@ async function main(engine) {
 
                 const aabb_array = [];
                 const position_attribute = geometry.getAttribute('position');
-                compute_aabb_from_points(aabb_array, position_attribute.array, position_attribute.count, 3);
+                compute_aabb_from_points(aabb_array, position_attribute.array, 0, position_attribute.count, 3);
                 const aabb3 = new AABB3(...aabb_array);
                 //
                 // weld_duplicate_vertices(topo, aabb3);

package/core/geom/3d/topology/simplify/compute_face_normal_change_dot_product.js

@@ -1,5 +1,5 @@
 import { v3_dot } from "../../../v3_dot.js";
-import { compute_triangle_normal } from "../struct/TopoTriangle.js";
+import { compute_triangle_normal } from "../../compute_triangle_normal.js";
 
 const scratch_normal = new Float32Array(3);
 

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,8 +1,8 @@
 import { v3_dot } from "../../../../v3_dot.js";
 import { fabsf } from "../../../../../math/fabsf.js";
 import { vec3 } from "gl-matrix";
-import { compute_triangle_normal } from "../../struct/TopoTriangle.js";
 import { EPSILON } from "../../../../../math/EPSILON.js";
+import { compute_triangle_normal } from "../../../compute_triangle_normal.js";
 
 const scratch_v3 = new Float32Array(3);