@woosh/meep-engine 2.61.0 → 2.62.0

package/build/meep.module.js

@@ -49814,6 +49814,95 @@ function array_quick_sort_by_comparator(
     }
 }
 
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+function aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1) {
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const dz = z1 - z0;
+    return dy * (dx + dz) + dz * dx; //1 side, since it's a heuristic only
+}
+
+/**
+ *
+ * @param {AABB3} node
+ * @returns {number}
+ */
+function aabb3_box_surface_area_2(node) {
+    return aabb3_compute_half_surface_area(node.x0, node.y0, node.z0, node.x1, node.y1, node.z1);
+}
+
+/**
+ *
+ * @param {AABB3} a
+ * @param {AABB3} b
+ * @returns {number}
+ */
+function aabb3_combined_surface_area(a, b) {
+    const x0 = min2(a.x0, b.x0);
+    const y0 = min2(a.y0, b.y0);
+    const z0 = min2(a.z0, b.z0);
+
+    const x1 = max2(a.x1, b.x1);
+    const y1 = max2(a.y1, b.y1);
+    const z1 = max2(a.z1, b.z1);
+
+    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
+}
+
+/**
+ * Returns true if two 1D lines intersect, touch is treated as intersection
+ * Parameters are assumed to be ordered, a1 >= a0, b1 >= b0
+ * @param {Number} a0
+ * @param {Number} a1
+ * @param {Number} b0
+ * @param {Number} b1
+ * @returns {boolean}
+ */
+function intersects1D(a0, a1, b0, b1) {
+    assert.isNumber(a0, "a0");
+    assert.isNumber(a1, "a1");
+    assert.isNumber(b0, "b0");
+    assert.isNumber(b1, "b1");
+
+    return a1 >= b0 && b1 >= a0;
+}
+
+/**
+ *
+ * @param {number} ax0
+ * @param {number} ay0
+ * @param {number} az0
+ * @param {number} ax1
+ * @param {number} ay1
+ * @param {number} az1
+ * @param {number} bx0
+ * @param {number} by0
+ * @param {number} bz0
+ * @param {number} bx1
+ * @param {number} by1
+ * @param {number} bz1
+ * @returns {boolean}
+ */
+function aabb3_intersects_aabb3(
+    ax0, ay0, az0,
+    ax1, ay1, az1,
+    bx0, by0, bz0,
+    bx1, by1, bz1
+) {
+    return intersects1D(ax0, ax1, bx0, bx1)
+        && intersects1D(ay0, ay1, by0, by1)
+        && intersects1D(az0, az1, bz0, bz1);
+}
+
 /**
  *
  * @param {number[]} values
@@ -49900,6 +49989,73 @@ function mortonEncode_magicbits(x, y, z) {
     return x_bits | y_bits | z_bits;
 }
 
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]|AABB3} aabb
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+function aabb3_array_intersects_point(
+    aabb,
+    x, y, z
+) {
+    return x >= aabb[0]
+        && x <= aabb[3]
+        && y >= aabb[1]
+        && y <= aabb[4]
+        && z >= aabb[2]
+        && z <= aabb[5];
+}
+
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} destination
+ * @param {number} destination_offset
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+function aabb3_build_corners(destination, destination_offset, x0, y0, z0, x1, y1, z1) {
+    destination[destination_offset] = x0;
+    destination[destination_offset + 1] = y0;
+    destination[destination_offset + 2] = z0;
+
+    destination[destination_offset + 3] = x1;
+    destination[destination_offset + 4] = y0;
+    destination[destination_offset + 5] = z0;
+
+    destination[destination_offset + 6] = x0;
+    destination[destination_offset + 7] = y1;
+    destination[destination_offset + 8] = z0;
+
+    destination[destination_offset + 9] = x1;
+    destination[destination_offset + 10] = y1;
+    destination[destination_offset + 11] = z0;
+
+    destination[destination_offset + 12] = x0;
+    destination[destination_offset + 13] = y0;
+    destination[destination_offset + 14] = z1;
+
+    destination[destination_offset + 15] = x1;
+    destination[destination_offset + 16] = y0;
+    destination[destination_offset + 17] = z1;
+
+    destination[destination_offset + 18] = x0;
+    destination[destination_offset + 19] = y1;
+    destination[destination_offset + 20] = z1;
+
+    destination[destination_offset + 21] = x1;
+    destination[destination_offset + 22] = y1;
+    destination[destination_offset + 23] = z1;
+}
+
 /**
  * Distance of the farthest point along the plane normal from the plane. If the result is >= 0, at least a portion of AABB pokes above the plane
  * @param {number} plane_normal_x
@@ -50014,47 +50170,53 @@ function aabb3_compute_plane_side(
 
 /**
  *
- * @param {number[]|Float32Array|Float64Array} destination
- * @param {number} destination_offset
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
  * @param {number} x1
  * @param {number} y1
  * @param {number} z1
+ * @returns {number}
  */
-function aabb3_build_corners(destination, destination_offset, x0, y0, z0, x1, y1, z1) {
-    destination[destination_offset] = x0;
-    destination[destination_offset + 1] = y0;
-    destination[destination_offset + 2] = z0;
-
-    destination[destination_offset + 3] = x1;
-    destination[destination_offset + 4] = y0;
-    destination[destination_offset + 5] = z0;
-
-    destination[destination_offset + 6] = x0;
-    destination[destination_offset + 7] = y1;
-    destination[destination_offset + 8] = z0;
+function aabb3_compute_surface_area(x0, y0, z0, x1, y1, z1) {
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const dz = z1 - z0;
+    return (dy * (dx + dz) + dz * dx) * 2; //2 of each side
+}
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} frustum
+ * @return {boolean}
+ */
+function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum) {
+    for (let i = 0; i < 24; i += 4) {
 
-    destination[destination_offset + 9] = x1;
-    destination[destination_offset + 10] = y1;
-    destination[destination_offset + 11] = z0;
+        const plane_x = frustum[i];
+        const plane_y = frustum[i + 1];
+        const plane_z = frustum[i + 2];
+        const plane_w = frustum[i + 3];
 
-    destination[destination_offset + 12] = x0;
-    destination[destination_offset + 13] = y0;
-    destination[destination_offset + 14] = z1;
+        const plane_distance = aabb3_compute_distance_above_plane_max(
+            plane_x, plane_y, plane_z, plane_w,
+            x0, y0, z0,
+            x1, y1, z1
+        );
 
-    destination[destination_offset + 15] = x1;
-    destination[destination_offset + 16] = y0;
-    destination[destination_offset + 17] = z1;
+        if (plane_distance < 0) {
+            return false;
+        }
 
-    destination[destination_offset + 18] = x0;
-    destination[destination_offset + 19] = y1;
-    destination[destination_offset + 20] = z1;
+    }
 
-    destination[destination_offset + 21] = x1;
-    destination[destination_offset + 22] = y1;
-    destination[destination_offset + 23] = z1;
+    return true;
 }
 
 //
@@ -50274,57 +50436,6 @@ function aabb3_intersects_ray(
     return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
 }
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-function aabb3_compute_surface_area(x0, y0, z0, x1, y1, z1) {
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    const dz = z1 - z0;
-    return (dy * (dx + dz) + dz * dx) * 2; //2 of each side
-}
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} frustum
- * @return {boolean}
- */
-function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum) {
-    for (let i = 0; i < 24; i += 4) {
-
-        const plane_x = frustum[i];
-        const plane_y = frustum[i + 1];
-        const plane_z = frustum[i + 2];
-        const plane_w = frustum[i + 3];
-
-        const plane_distance = aabb3_compute_distance_above_plane_max(
-            plane_x, plane_y, plane_z, plane_w,
-            x0, y0, z0,
-            x1, y1, z1
-        );
-
-        if (plane_distance < 0) {
-            return false;
-        }
-
-    }
-
-    return true;
-}
-
 /**
  * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
  * NOTE: {@link result} and {@link aabb} must be different objects
@@ -50407,26 +50518,33 @@ function aabb3_signed_distance_sqr_to_point(
     }
 }
 
-//
+function aabb3_signed_distance_to_aabb3(
+    ax0,ay0,az0,ax1,ay1,az1,
+    bx0,by0,bz0, bx1,by1,bz1
+){
 
-/**
- *
- * @param {ArrayLike<number>|number[]|AABB3} aabb
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @return {boolean}
- */
-function aabb3_array_intersects_point(
-    aabb,
-    x, y, z
-) {
-    return x >= aabb[0]
-        && x <= aabb[3]
-        && y >= aabb[1]
-        && y <= aabb[4]
-        && z >= aabb[2]
-        && z <= aabb[5];
+    //do projection
+    const xp0 = bx0 - ax1;
+    const xp1 = ax0 - bx1;
+    const yp0 = by0 - ay1;
+    const yp1 = ay0 - by1;
+    const zp0 = bz0 - az1;
+    const zp1 = az0 - bz1;
+
+    //calculate separation in each axis
+    const dx = Math.max(xp0, xp1);
+    const dy = Math.max(yp0, yp1);
+    const dz = Math.max(zp0, zp1);
+
+    //straight-line distance
+    let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+    if (dx < 0 && dy < 0 && dz < 0) {
+        //penetration
+        return -distance;
+    } else {
+        return distance;
+    }
 }
 
 /**
@@ -50435,6 +50553,7 @@ function aabb3_array_intersects_point(
 
 /**
  * Axis-Aligned bounding box in 3D
+ * NOTE: In cases where all you want is raw performance - prefer to use typed arrays instead along with `aabb3_` functions
  */
 class AABB3 {
     /**
@@ -50654,7 +50773,12 @@ class AABB3 {
      * @returns {boolean}
      */
     _equals(x0, y0, z0, x1, y1, z1) {
-        return this.x0 === x0 && this.y0 === y0 && this.z0 === z0 && this.x1 === x1 && this.y1 === y1 && this.z1 === z1;
+        return this.x0 === x0
+            && this.y0 === y0
+            && this.z0 === z0
+            && this.x1 === x1
+            && this.y1 === y1
+            && this.z1 === z1;
     }
 
     /**
@@ -50748,28 +50872,10 @@ class AABB3 {
         const _y1 = this.y1;
         const _z1 = this.z1;
 
-        //do projection
-        const xp0 = _x0 - x1;
-        const xp1 = x0 - _x1;
-        const yp0 = _y0 - y1;
-        const yp1 = y0 - _y1;
-        const zp0 = _z0 - z1;
-        const zp1 = z0 - _z1;
-
-        //calculate separation in each axis
-        const dx = Math.max(xp0, xp1);
-        const dy = Math.max(yp0, yp1);
-        const dz = Math.max(zp0, zp1);
-
-        //straight-line distance
-        let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
-        if (dx < 0 && dy < 0 && dz < 0) {
-            //penetration
-            return -distance;
-        } else {
-            return distance;
-        }
+        return aabb3_signed_distance_to_aabb3(
+            _x0, _y0, _z0, _x1, _y1, _z1,
+            x0, y0, z0, x1, y1, z1
+        );
     }
 
     /**
@@ -51194,7 +51300,6 @@ class AABB3 {
     }
 
     /**
-     *
      * @param {Plane[]} clippingPlanes
      * @returns {boolean}
      */
@@ -51489,6 +51594,9 @@ function isLeaf(node) {
     return node.isLeafNode;
 }
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} and {@link EBBVHLeafProxy} respectively
+ */
 class LeafNode extends Node {
     /**
      *
@@ -51699,95 +51807,6 @@ function traverseBinaryNodeUsingVisitor(node, visitor) {
     stackPointer$3 = stackOffset;
 }
 
-/**
- * Returns true if two 1D lines intersect, touch is treated as intersection
- * Parameters are assumed to be ordered, a1 >= a0, b1 >= b0
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {boolean}
- */
-function intersects1D(a0, a1, b0, b1) {
-    assert.isNumber(a0, "a0");
-    assert.isNumber(a1, "a1");
-    assert.isNumber(b0, "b0");
-    assert.isNumber(b1, "b1");
-
-    return a1 >= b0 && b1 >= a0;
-}
-
-/**
- *
- * @param {number} ax0
- * @param {number} ay0
- * @param {number} az0
- * @param {number} ax1
- * @param {number} ay1
- * @param {number} az1
- * @param {number} bx0
- * @param {number} by0
- * @param {number} bz0
- * @param {number} bx1
- * @param {number} by1
- * @param {number} bz1
- * @returns {boolean}
- */
-function aabb3_intersects_aabb3(
-    ax0, ay0, az0,
-    ax1, ay1, az1,
-    bx0, by0, bz0,
-    bx1, by1, bz1
-) {
-    return intersects1D(ax0, ax1, bx0, bx1)
-        && intersects1D(ay0, ay1, by0, by1)
-        && intersects1D(az0, az1, bz0, bz1);
-}
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-function aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1) {
-    const dx = x1 - x0;
-    const dy = y1 - y0;
-    const dz = z1 - z0;
-    return dy * (dx + dz) + dz * dx; //1 side, since it's a heuristic only
-}
-
-/**
- *
- * @param {AABB3} node
- * @returns {number}
- */
-function aabb3_box_surface_area_2(node) {
-    return aabb3_compute_half_surface_area(node.x0, node.y0, node.z0, node.x1, node.y1, node.z1);
-}
-
-/**
- *
- * @param {AABB3} a
- * @param {AABB3} b
- * @returns {number}
- */
-function aabb3_combined_surface_area(a, b) {
-    const x0 = min2(a.x0, b.x0);
-    const y0 = min2(a.y0, b.y0);
-    const z0 = min2(a.z0, b.z0);
-
-    const x1 = max2(a.x1, b.x1);
-    const y1 = max2(a.y1, b.y1);
-    const z1 = max2(a.z1, b.z1);
-
-    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
-}
-
 /**
  * Created by Alex on 17/11/2014.
  */
@@ -51811,6 +51830,9 @@ let stackPointer$2 = 0;
  */
 const stack$9 = [];
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} instead
+ */
 class BinaryNode extends Node {
     constructor() {
         super();

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.61.0",
+  "version": "2.62.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/BinaryNode.js

@@ -3,19 +3,19 @@
  */
 
 
-import { assert } from "../assert.js";
-import { arrayQuickSort } from "../collection/array/arrayQuickSort.js";
-import { max2 } from "../math/max2.js";
-import { min2 } from "../math/min2.js";
-import { computeSampleStandardDeviation } from "../math/statistics/computeSampleStandardDeviation.js";
-import { isLeaf, LeafNode } from "./LeafNode.js";
-import { Node } from "./Node.js";
-import { surfaceAreaHeuristic } from "./sah/surfaceAreaHeuristic.js";
-import { BVHVisitor } from "./traversal/BVHVisitor.js";
-import { traverseBinaryNodeUsingVisitor } from "./traversal/traverseBinaryNodeUsingVisitor.js";
-import { aabb3_intersects_aabb3 } from "../geom/3d/aabb/aabb3_intersects_aabb3.js";
-import { aabb3_box_surface_area_2 } from "../geom/3d/aabb/aabb3_box_surface_area_2.js";
-import { aabb3_combined_surface_area } from "../geom/3d/aabb/aabb3_combined_surface_area.js";
+import {assert} from "../assert.js";
+import {arrayQuickSort} from "../collection/array/arrayQuickSort.js";
+import {aabb3_box_surface_area_2} from "../geom/3d/aabb/aabb3_box_surface_area_2.js";
+import {aabb3_combined_surface_area} from "../geom/3d/aabb/aabb3_combined_surface_area.js";
+import {aabb3_intersects_aabb3} from "../geom/3d/aabb/aabb3_intersects_aabb3.js";
+import {max2} from "../math/max2.js";
+import {min2} from "../math/min2.js";
+import {computeSampleStandardDeviation} from "../math/statistics/computeSampleStandardDeviation.js";
+import {isLeaf, LeafNode} from "./LeafNode.js";
+import {Node} from "./Node.js";
+import {surfaceAreaHeuristic} from "./sah/surfaceAreaHeuristic.js";
+import {BVHVisitor} from "./traversal/BVHVisitor.js";
+import {traverseBinaryNodeUsingVisitor} from "./traversal/traverseBinaryNodeUsingVisitor.js";
 
 
 /**
@@ -36,6 +36,9 @@ let stackPointer = 0;
  */
 const stack = [];
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} instead
+ */
 export class BinaryNode extends Node {
     constructor() {
         super();

package/src/core/bvh2/LeafNode.js

@@ -1,9 +1,9 @@
 /**
  * Created by Alex on 17/11/2014.
  */
-import { Node } from "./Node.js";
-import { serializeAABB3 } from "../geom/3d/aabb/serializeAABB3.js";
-import { deserializeAABB3 } from "../geom/3d/aabb/deserializeAABB3.js";
+import {deserializeAABB3} from "../geom/3d/aabb/deserializeAABB3.js";
+import {serializeAABB3} from "../geom/3d/aabb/serializeAABB3.js";
+import {Node} from "./Node.js";
 
 
 /**
@@ -15,6 +15,9 @@ function isLeaf(node) {
     return node.isLeafNode;
 }
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} and {@link EBBVHLeafProxy} respectively
+ */
 export class LeafNode extends Node {
     /**
      *

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

@@ -0,0 +1,81 @@
+import {SCRATCH_UINT32_TRAVERSAL_STACK} from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {aabb3_array_intersects_sphere_array} from "../../../geom/3d/aabb/aabb3_array_intersects_sphere_array.js";
+import {NULL_NODE} from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import {bvh_collect_user_data} from "./bvh_collect_user_data.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+const scratch_aabb = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} sphere
+ */
+export function bvh_query_user_data_overlaps_sphere(
+    result,
+    result_offset,
+    bvh,
+    sphere
+) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    while (stack.pointer > stack_top) {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        // test node against the ray
+        bvh.node_get_aabb(node, scratch_aabb);
+        const intersection = aabb3_array_intersects_sphere_array(scratch_aabb, sphere);
+
+        if (intersection === 0) {
+            // fully outside
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (node_is_leaf) {
+            // leaf node
+            result[result_cursor++] = bvh.node_get_user_data(node);
+
+        } else if (intersection === 2) {
+            // fully inside, fast collection path
+            result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
+        } else {
+            // partially inside
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            stack[stack.pointer++] = child1;
+            stack[stack.pointer++] = child2;
+        }
+    }
+
+    // drop stack frame
+
+    return result_cursor - result_offset;
+}