@woosh/meep-engine 2.48.22 → 2.49.0

package/src/core/geom/3d/{CircleMath.js → compute_circle_bounding_box.js}

@@ -12,7 +12,7 @@ import { v3_angle_between } from "../v3_angle_between.js";
  * @param {number} normalZ orientation of the circle
  * @param {number} radius
  */
-export function computeCircleBoundingBox(
+export function compute_circle_bounding_box(
     result,
     centerX, centerY, centerZ,
     normalX, normalY, normalZ,

package/src/core/geom/3d/decompose_matrix_4_array.js

@@ -2,34 +2,35 @@ const hypot = Math.hypot;
 
 /**
  *
- * @param {number[]} m
+ * @param {number[]} mat4
  * @param {Vector3} position
  * @param {Quaternion} rotation
  * @param {Vector3} scale
  */
-export function decompose_matrix_4_array(m, position, rotation, scale) {
-    const m11 = m[0];
-    const m12 = m[1];
-    const m13 = m[2];
+export function decompose_matrix_4_array(mat4, position, rotation, scale) {
+    const m11 = mat4[0];
+    const m12 = mat4[1];
+    const m13 = mat4[2];
 
     const scale_x = hypot(m11, m12, m13);
 
-    const m21 = m[4];
-    const m22 = m[5];
-    const m23 = m[6];
+    const m21 = mat4[4];
+    const m22 = mat4[5];
+    const m23 = mat4[6];
 
     const scale_y = hypot(m21, m22, m23);
 
-    const m31 = m[8];
-    const m32 = m[9];
-    const m33 = m[10];
+    const m31 = mat4[8];
+    const m32 = mat4[9];
+    const m33 = mat4[10];
 
     const scale_z = hypot(m31, m32, m33);
 
     // extract rotation matrix
-    const is1 = 1 / scale_x;
-    const is2 = 1 / scale_y;
-    const is3 = 1 / scale_z;
+    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
+    const is1 = scale_x !== 0 ? 1 / scale_x : 1e7;
+    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
+    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
 
     const sm11 = m11 * is1;
     const sm12 = m12 * is1;
@@ -43,14 +44,12 @@ export function decompose_matrix_4_array(m, position, rotation, scale) {
     const sm32 = m32 * is3;
     const sm33 = m33 * is3;
 
-    // TODO take care of cases where scale is 0
-
     // write out results
 
     position.set(
-        m[12],
-        m[13],
-        m[14]
+        mat4[12],
+        mat4[13],
+        mat4[14]
     );
 
     scale.set(

package/src/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js

@@ -1,4 +1,3 @@
-import { computePlanePlaneIntersection } from "../../Plane.js";
 import Vector3 from "../../Vector3.js";
 import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
 import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
@@ -6,6 +5,7 @@ import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import {
     plane_three_computeConvex3PlaneIntersection
 } from "../plane/plane_three_compute_convex3_plane_intersection.js";
+import { computePlanePlaneIntersection } from "../plane/computePlanePlaneIntersection.js";
 
 /**
  *

package/src/{engine/graphics/ecs/mesh-v2 → core/geom/3d/matrix}/allocate_transform_m4.js

@@ -1,4 +1,4 @@
-import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
 
 /**
  * Larger bucket sizes provide better cache locality

package/src/core/geom/3d/normal/hemioct/decode_hemioct_to_unit.js

@@ -0,0 +1,26 @@
+/**
+ * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014)
+ *
+ * Uses hemi-octahedron for sphere approximation
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [-1,1]
+ * @param {number} y range [-1,1]
+ */
+export function decode_hemioct_to_unit(output, output_offset, x, y) {
+    // Rotate and scale the unit square back to the center diamond
+    const t_x = (x + y) * 0.5;
+    const t_y = (x - y) * 0.5;
+
+    //
+    const v_z = 1.0 - Math.abs(t_x) - Math.abs(t_y);
+
+    // normalize
+    const l2 = (t_x * t_x + t_y * t_y + v_z * v_z);
+    const m = 1 / Math.sqrt(l2);
+
+    output[output_offset] = t_x * m;
+    output[output_offset + 1] = t_y * m;
+    output[output_offset + 2] = v_z * m;
+}

package/src/core/geom/3d/normal/hemioct/encode_unit3_hemioct.js

@@ -27,29 +27,3 @@ export function encode_unit_to_hemioct(output, output_offset, x, y, z) {
     output[output_offset + 1] = _y;
 }
 
-/**
- * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014)
- *
- * Uses hemi-octahedron for sphere approximation
- *
- * @param {number[]} output
- * @param {number} output_offset
- * @param {number} x range [-1,1]
- * @param {number} y range [-1,1]
- */
-export function decode_hemioct_to_unit(output, output_offset, x, y) {
-    // Rotate and scale the unit square back to the center diamond
-    const t_x = (x + y) * 0.5;
-    const t_y = (x - y) * 0.5;
-
-    //
-    const v_z = 1.0 - Math.abs(t_x) - Math.abs(t_y);
-
-    // normalize
-    const l2 = (t_x * t_x + t_y * t_y + v_z * v_z);
-    const m = 1 / Math.sqrt(l2);
-
-    output[output_offset] = t_x * m;
-    output[output_offset + 1] = t_y * m;
-    output[output_offset + 2] = v_z * m;
-}

package/src/core/geom/3d/normal/hemioct/unit_hemioct.spec.js

@@ -1,5 +1,6 @@
-import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
+import { encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
 import { v3_length } from "../../../v3_length.js";
+import { decode_hemioct_to_unit } from "./decode_hemioct_to_unit.js";
 
 test('encode-decode', () => {
     const v0 = [];

package/src/core/geom/3d/plane/computePlaneLineIntersection.js

@@ -0,0 +1,51 @@
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ *
+ * @param {Vector3} out Result will be written here
+ * @param {number} originX Ray origin
+ * @param {number} originY Ray origin
+ * @param {number} originZ Ray origin
+ * @param {number} directionX Ray direction
+ * @param {number} directionY Ray direction
+ * @param {number} directionZ Ray direction
+ * @param {number} normalX Plane normal
+ * @param {number} normalY Plane normal
+ * @param {number} normalZ Plane normal
+ * @param {number} dist Plane distance
+ * @returns {boolean} true if intersection is found, false otherwise
+ */
+export function computePlaneLineIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
+    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
+
+    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
+
+    if (denom !== 0) {
+
+        const t = -p / denom;
+
+        out.set(
+            directionX * t + originX,
+            directionY * t + originY,
+            directionZ * t + originZ
+        );
+
+        return true;
+
+    } else {
+
+        if (p === 0) {
+
+            out.set(originX, originY, originZ);
+
+            return true;
+
+        } else {
+
+            //no intersection
+            return false;
+
+        }
+
+    }
+}

package/src/core/geom/3d/plane/computePlanePlaneIntersection.js

@@ -0,0 +1,77 @@
+/**
+
+ Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the
+ section 'Intersection of 2 Planes' and specifically the subsection
+ (A) Direct Linear Equation
+ @param {Plane} p1
+ @param {Plane} p2
+ @param {Vector3} point
+ @param {Vector3} direction
+ @returns {boolean}
+ */
+export function computePlanePlaneIntersection(p1, p2, point, direction) {
+
+    // the cross product gives us the direction of the line at the intersection
+    // of the two planes, and gives us an easy way to check if the two planes
+    // are parallel - the cross product will have zero magnitude
+
+    direction.crossVectors(p1.normal, p2.normal);
+
+    const magnitude = direction.lengthSqr();
+
+    if (magnitude === 0) {
+        return false;
+    }
+
+    // now find a point on the intersection. We use the 'Direct Linear Equation'
+    // method described in the linked page, and we choose which coordinate
+    // to set as zero by seeing which has the largest absolute value in the
+    // directional vector
+
+    const X = Math.abs(direction.x);
+    const Y = Math.abs(direction.y);
+    const Z = Math.abs(direction.z);
+
+    if (Z >= X && Z >= Y) {
+        solveIntersectingPoint('z', 'x', 'y', p1, p2, point);
+    } else if (Y >= Z && Y >= X) {
+        solveIntersectingPoint('y', 'z', 'x', p1, p2, point);
+    } else {
+        solveIntersectingPoint('x', 'y', 'z', p1, p2, point);
+    }
+
+    return true;
+}
+
+/**
+
+ This method helps finding a point on the intersection between two planes.
+ Depending on the orientation of the planes, the problem could solve for the
+ zero point on either the x, y or z axis
+ * @param {string} zeroCoord
+ * @param {string} A
+ * @param {string} B
+ * @param {THREE.Plane} p1
+ * @param {THREE.Plane} p2
+ * @param {Vector3} result
+ */
+function solveIntersectingPoint(zeroCoord, A, B, p1, p2, result) {
+    const nP1 = p1.normal;
+
+    const a1 = nP1[A];
+    const b1 = nP1[B];
+    const d1 = p1.constant;
+
+    const nP2 = p2.normal;
+
+    const a2 = nP2[A];
+    const b2 = nP2[B];
+    const d2 = p2.constant;
+
+    const A0 = ((b2 * d1) - (b1 * d2)) / ((a1 * b2 - a2 * b1));
+    const B0 = ((a1 * d2) - (a2 * d1)) / ((a1 * b2 - a2 * b1));
+
+    result[zeroCoord] = 0;
+    result[A] = A0;
+    result[B] = B0;
+}

package/src/core/geom/3d/plane/computePlaneRayIntersection.js

@@ -0,0 +1,55 @@
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ *
+ * @param {Vector3} out Result will be written here
+ * @param {number} originX Ray origin
+ * @param {number} originY Ray origin
+ * @param {number} originZ Ray origin
+ * @param {number} directionX Ray direction
+ * @param {number} directionY Ray direction
+ * @param {number} directionZ Ray direction
+ * @param {number} normalX Plane normal
+ * @param {number} normalY Plane normal
+ * @param {number} normalZ Plane normal
+ * @param {number} dist Plane distance
+ * @returns {boolean} true if intersection is found, false otherwise
+ */
+export function computePlaneRayIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
+    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
+
+    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
+
+    if (denom !== 0) {
+
+        const t = -p / denom;
+
+        if (t < 0) {
+            return false;
+        }
+
+        out.set(
+            directionX * t + originX,
+            directionY * t + originY,
+            directionZ * t + originZ
+        );
+
+        return true;
+
+    } else {
+
+        if (p === 0) {
+
+            out.set(originX, originY, originZ);
+
+            return true;
+
+        } else {
+
+            //no intersection
+            return false;
+
+        }
+
+    }
+}

package/src/core/geom/3d/plane/plane3_computeLineSegmentIntersection.js

@@ -0,0 +1,50 @@
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ *
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} normalX
+ * @param {number} normalY
+ * @param {number} normalZ
+ * @param {number} dist
+ * @returns {boolean}
+ */
+export function plane3_computeLineSegmentIntersection(
+    result, result_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    normalX, normalY, normalZ, dist
+) {
+
+    const directionX = x1 - x0;
+    const directionY = y1 - y0;
+    const directionZ = z1 - z0;
+
+    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
+
+    if (denom === 0) {
+        return false;
+    }
+
+    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
+
+    const t = -p / denom;
+
+    if (t < 0 || t > 1) {
+        return false;
+    }
+
+    result[result_offset] = directionX * t + x0;
+    result[result_offset + 1] = directionY * t + y0;
+    result[result_offset + 2] = directionZ * t + z0;
+
+    return true;
+
+}

package/src/core/geom/3d/plane/planeRayIntersection.js

@@ -0,0 +1,14 @@
+import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
+
+/**
+ *
+ * @param {Vector3} out Result will be written here
+ * @param {Vector3} origin Ray origin
+ * @param {Vector3} direction Ray direction
+ * @param {Vector3} normal Plane normal
+ * @param {number} dist Plane distance
+ * @returns {boolean} true if intersection is found, false otherwise
+ */
+export function planeRayIntersection(out, origin, direction, normal, dist) {
+    return computePlaneRayIntersection(out, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, normal.x, normal.y, normal.z, dist)
+}

package/src/core/geom/3d/{tetrahedra/in_sphere_fast.js → sphere/in_sphere3d_fast.js}

@@ -19,7 +19,7 @@
  * @param {number} e reference point index that we are testing against the tetrahedron
  * @returns {number}
  */
-export function in_sphere_fast(
+export function in_sphere3d_fast(
     points,
     a, b, c, d, e
 ) {

package/src/core/geom/3d/{tetrahedra/in_sphere_robust.js → sphere/in_sphere3d_robust.js}

@@ -12,7 +12,7 @@ import { insphere } from "robust-predicates";
  * @param {number} e reference point index that we are testing against the tetrahedron
  * @returns {number}
  */
-export function in_sphere_robust(
+export function in_sphere3d_robust(
     points,
     a, b, c, d, e
 ) {

package/src/core/geom/3d/sphere/sphere_array_intersects_point.js

@@ -1,4 +1,4 @@
-import { sphereIntersectsPoint } from "./sphereIntersectsPoint.js";
+import { sphere_intersects_point } from "./sphere_intersects_point.js";
 
 //
 
@@ -11,5 +11,5 @@ import { sphereIntersectsPoint } from "./sphereIntersectsPoint.js";
  * @return {boolean}
  */
 export function sphere_array_intersects_point(sphere, x, y, z) {
-    return sphereIntersectsPoint(sphere[0], sphere[1], sphere[2], sphere[3], x, y, z);
+    return sphere_intersects_point(sphere[0], sphere[1], sphere[2], sphere[3], x, y, z);
 }

package/src/core/geom/3d/sphere/{sphereIntersectsPoint.js → sphere_intersects_point.js}

@@ -4,12 +4,15 @@
  * @param {number} center_y
  * @param {number} center_z
  * @param {number} radius
- * @param {number} p_x
- * @param {number} p_y
- * @param {number} p_z
+ * @param {number} p_x reference point X coordinate
+ * @param {number} p_y reference point Y coordinate
+ * @param {number} p_z reference point Z coordinate
  * @returns {boolean}
  */
-export function sphereIntersectsPoint(center_x, center_y, center_z, radius, p_x, p_y, p_z) {
+export function sphere_intersects_point(
+    center_x, center_y, center_z, radius,
+    p_x, p_y, p_z
+) {
 
     //compute offset vector
     const dx = center_x - p_x;

package/src/core/geom/3d/sphere/sphere_intersects_point.spec.js

@@ -0,0 +1,134 @@
+import { sphere_intersects_point } from "./sphere_intersects_point.js";
+
+test("zero volume sphere", () => {
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        0, 0, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        -1, 0, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        1, 0, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        0, -1, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        0, 1, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        0, 0, -1
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 0,
+        0, 0, 1
+    )).toBe(false)
+
+});
+
+test("out of bounds, centered on origin", () => {
+
+    // X
+    expect(sphere_intersects_point(
+        0, 0, 0, 1,
+        -2, 0, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 1,
+        2, 0, 0
+    )).toBe(false)
+
+
+    // Y
+    expect(sphere_intersects_point(
+        0, 0, 0, 1,
+        0, -2, 0
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 1,
+        0, 2, 0
+    )).toBe(false)
+
+    // Z
+    expect(sphere_intersects_point(
+        0, 0, 0, 1,
+        0, 0, -2
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 1,
+        0, 0, 2
+    )).toBe(false)
+
+});
+
+test("out of bounds with offset origin", () => {
+
+    expect(sphere_intersects_point(
+        3, -5, 7, 1,
+        1, -5, 7
+    )).toBe(false)
+
+    expect(sphere_intersects_point(
+        3, -5, 7, 1,
+        5, -5, 7
+    )).toBe(false)
+
+});
+
+test("in bounds", () => {
+
+    expect(sphere_intersects_point(
+        0, 0, 0, 2,
+        0, 0, 0
+    )).toBe(true)
+
+    // X
+    expect(sphere_intersects_point(
+        0, 0, 0, 2,
+        -1, 0, 0
+    )).toBe(true)
+
+    expect(sphere_intersects_point(
+        5, 5, 5, 2,
+        4, 5, 5
+    )).toBe(true)
+
+    // Y
+    expect(sphere_intersects_point(
+        0, 0, 0, 2,
+        0, -1, 0
+    )).toBe(true)
+
+    expect(sphere_intersects_point(
+        5, 5, 5, 2,
+        5, 4, 5
+    )).toBe(true)
+
+    // Z
+    expect(sphere_intersects_point(
+        0, 0, 0, 2,
+        0, 0, -1
+    )).toBe(true)
+
+    expect(sphere_intersects_point(
+        5, 5, 5, 2,
+        5, 5, 4
+    )).toBe(true)
+
+});

package/src/core/geom/3d/sphere/sphere_intersects_ray.spec.js

@@ -0,0 +1,49 @@
+import { sphere_intersects_ray } from "./sphere_intersects_ray.js";
+
+test("ray from -X to +X intersects sphere", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        -2, 0, 0,
+        1, 0, 0
+    )).toBe(true);
+});
+
+test("ray from +X to -X intersects sphere", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        2, 0, 0,
+        -1, 0, 0
+    )).toBe(true);
+});
+
+test("ray from -Y to +Y intersects sphere", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        0, -2, 0,
+        0, 1, 0
+    )).toBe(true);
+});
+
+test("ray from +Y to -Y intersects sphere", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        0, 2, 0,
+        0, -1, 0
+    )).toBe(true);
+});
+
+test("ray from -Z to +Z intersects sphere", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        0, 0, -2,
+        0, 0, 1
+    )).toBe(true);
+});
+
+test("ray from +Z to -Z intersects sphere", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        0, 0, 2,
+        0, 0, -1
+    )).toBe(true);
+});

package/src/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.js

@@ -1,11 +1,15 @@
 /**
- *
+ * Compute squared radius of bonding sphere centered on 0,0,0 from a set of points and a transform matrix that is to be applied to the points prior to calculation of bounds
  * @param {number[]|ArrayLike<number>} input
- * @param {number} input_length
- * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @param {number} input_length length of the input array, foe example if there is just 1 vector in the input, length will be 3
+ * @param {ArrayLike<number>|number[]|Float32Array} mat4 4x4 transformation matrix
  * @returns {number}
  */
-export function sphere_radius_sqr_from_v3_array_transformed(input, input_length, e) {
+export function sphere_radius_sqr_from_v3_array_transformed(
+    input,
+    input_length,
+    mat4
+) {
     let result = 0;
 
     for (let i = 0; i < input_length; i += 3) {
@@ -13,9 +17,9 @@ export function sphere_radius_sqr_from_v3_array_transformed(input, input_length,
         const y = input[i + 1];
         const z = input[i + 2];
 
-        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
-        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
-        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+        const _x = mat4[0] * x + mat4[4] * y + mat4[8] * z + mat4[12];
+        const _y = mat4[1] * x + mat4[5] * y + mat4[9] * z + mat4[13];
+        const _z = mat4[2] * x + mat4[6] * y + mat4[10] * z + mat4[14];
 
         const l2 = _x * _x + _y * _y + _z * _z;