@woosh/meep-engine 2.61.0 → 2.62.0

package/build/meep.cjs

@@ -49816,6 +49816,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
@@ -49902,6 +49991,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
@@ -50016,47 +50172,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;
 }
 
 //
@@ -50276,57 +50438,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
@@ -50409,26 +50520,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;
+    }
 }
 
 /**
@@ -50437,6 +50555,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 {
     /**
@@ -50656,7 +50775,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;
     }
 
     /**
@@ -50750,28 +50874,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
+        );
     }
 
     /**
@@ -51196,7 +51302,6 @@ class AABB3 {
     }
 
     /**
-     *
      * @param {Plane[]} clippingPlanes
      * @returns {boolean}
      */
@@ -51491,6 +51596,9 @@ function isLeaf(node) {
     return node.isLeafNode;
 }
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} and {@link EBBVHLeafProxy} respectively
+ */
 class LeafNode extends Node {
     /**
      *
@@ -51701,95 +51809,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.
  */
@@ -51813,6 +51832,9 @@ let stackPointer$2 = 0;
  */
 const stack$9 = [];
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} instead
+ */
 class BinaryNode extends Node {
     constructor() {
         super();