@woosh/meep-engine 2.49.9 → 2.50.1

package/src/core/geom/3d/plane/{computePlanePlaneIntersection.js → plane3_compute_plane_intersection.js}

@@ -3,21 +3,25 @@
  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
+ TODO consolidate with {@link plane3_intersect_plane} as they seem to do the same thing
  @param {Plane} p1
  @param {Plane} p2
- @param {Vector3} point
- @param {Vector3} direction
+ @param {Vector3} out_point
+ @param {Vector3} out_direction
  @returns {boolean}
  */
-export function computePlanePlaneIntersection(p1, p2, point, direction) {
+export function plane3_compute_plane_intersection(
+    p1, p2,
+    out_point, out_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);
+    out_direction.crossVectors(p1.normal, p2.normal);
 
-    const magnitude = direction.lengthSqr();
+    const magnitude = out_direction.lengthSqr();
 
     if (magnitude === 0) {
         return false;
@@ -28,16 +32,16 @@ export function computePlanePlaneIntersection(p1, p2, point, direction) {
     // 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);
+    const X = Math.abs(out_direction.x);
+    const Y = Math.abs(out_direction.y);
+    const Z = Math.abs(out_direction.z);
 
     if (Z >= X && Z >= Y) {
-        solveIntersectingPoint('z', 'x', 'y', p1, p2, point);
+        solveIntersectingPoint('z', 'x', 'y', p1, p2, out_point);
     } else if (Y >= Z && Y >= X) {
-        solveIntersectingPoint('y', 'z', 'x', p1, p2, point);
+        solveIntersectingPoint('y', 'z', 'x', p1, p2, out_point);
     } else {
-        solveIntersectingPoint('x', 'y', 'z', p1, p2, point);
+        solveIntersectingPoint('x', 'y', 'z', p1, p2, out_point);
     }
 
     return true;

package/src/core/geom/3d/plane/{computePlaneLineIntersection.js → plane3_compute_ray_intersection.js}

@@ -15,7 +15,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist Plane distance
  * @returns {boolean} true if intersection is found, false otherwise
  */
-export function computePlaneLineIntersection(
+export function plane3_compute_ray_intersection(
     out,
     originX, originY, originZ,
     directionX, directionY, directionZ,
@@ -29,6 +29,10 @@ export function computePlaneLineIntersection(
 
         const t = -p / denom;
 
+        if (t < 0) {
+            return false;
+        }
+
         out.set(
             directionX * t + originX,
             directionY * t + originY,

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

@@ -3,6 +3,20 @@ import Vector3 from "../../Vector3.js";
 const v0 = new Vector3();
 const v1 = new Vector3();
 
+/**
+ *
+ * @param {Vector3} result_point
+ * @param {Vector3} result_direction
+ * @param {number} a_normal_x
+ * @param {number} a_normal_y
+ * @param {number} a_normal_z
+ * @param {number} a_constant
+ * @param {number} b_normal_x
+ * @param {number} b_normal_y
+ * @param {number} b_normal_z
+ * @param {number} b_constant
+ * @return {boolean}
+ */
 export function plane3_intersect_plane(
     result_point,
     result_direction,

package/src/core/geom/3d/plane/{plane_three_compute_convex3_plane_intersection.js → plane3_three_compute_convex_3_plane_intersection.js}

@@ -1,7 +1,7 @@
-import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "./plane3_compute_convex_3_plane_intersection.js";
 
 /**
- *
+ * Works with THREE.js Plane representations as inputs
  * @param {number[]} result
  * @param {number} result_offset
  * @param {Plane} a
@@ -9,12 +9,15 @@ import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3Pla
  * @param {Plane} c
  * @returns {boolean}
  */
-export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
+export function plane3_three_compute_convex_3_plane_intersection(
+    result, result_offset,
+    a, b, c
+) {
     const a_normal = a.normal;
     const b_normal = b.normal;
     const c_normal = c.normal;
 
-    return plane_computeConvex3PlaneIntersection(
+    return plane3_compute_convex_3_plane_intersection(
         result,
         result_offset,
         a_normal.x, a_normal.y, a_normal.z, a.constant,

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

@@ -1,4 +1,4 @@
-import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
+import { plane3_compute_ray_intersection } from "./plane3_compute_ray_intersection.js";
 
 /**
  *
@@ -10,5 +10,5 @@ import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
  * @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)
+    return plane3_compute_ray_intersection(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/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -1,6 +1,6 @@
 import { max2 } from "../../../../math/max2.js";
 import { mat3, vec3 } from "gl-matrix";
-import { array_copy } from "../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
 import { assert } from "../../../../assert.js";
 

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -2,7 +2,7 @@ import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
 import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
 import { max3 } from "../../../math/max3.js";
 import { assert } from "../../../assert.js";
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { array_quick_sort_by_comparator } from "../../../collection/array/arrayQuickSort.js";
 import { compareNumbersDescending } from "../../../function/Functions.js";
 import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";

package/src/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.js

@@ -1,7 +1,7 @@
 import { v3_dot } from "../../v3_dot.js";
 import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
-import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "../plane/plane3_compute_convex_3_plane_intersection.js";
 
 /**
  * Planes used to bound the simplex
@@ -152,25 +152,25 @@ export function compute_bounding_simplex_3d(
     min_d -= padding;
 
     // let's compute intersection points for each tri-plane combination to find simplex corners
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 3,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
         SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 6,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 9,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,

package/src/core/geom/3d/tetrahedra/compute_circumsphere.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { v3_dot } from "../../v3_dot.js";
 
 const MAX_FLOAT32 = 3.4028234663852886e+38;

package/src/core/geom/3d/tetrahedra/delaunay/fill_in_a_cavity.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../assert.js";
-import { array_copy } from "../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
 import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
 import { validate_neighbour } from "../validate_tetrahedral_mesh.js";
 

package/src/core/geom/3d/topology/bounds/computeTriangleClusterNormalBoundingCone.js

@@ -1,7 +1,7 @@
 import { Miniball } from "../../../packing/miniball/Miniball.js";
 import { PointSet } from "../../../packing/miniball/PointSet.js";
 import { ConicRay } from "../../../ConicRay.js";
-import { array_copy } from "../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
 import { v3_angle_between } from "../../../v3_angle_between.js";
 

package/src/core/geom/3d/topology/expandConnectivityByLocality.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
 import { arraySetSortingDiff } from "../../../collection/array/arraySetSortingDiff.js";
 import { compareFaces } from "./compareFaces.js";

package/src/core/geom/3d/topology/struct/binary/BinaryTopology.js

@@ -1,5 +1,5 @@
 import { BinaryElementPool } from "./BinaryElementPool.js";
-import { array_copy } from "../../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../../collection/array/array_copy.js";
 import { assert } from "../../../../../assert.js";
 
 /**

package/src/core/geom/Quaternion.d.ts

@@ -1,5 +1,6 @@
 import Signal from "../events/signal/Signal";
 import {Matrix4, Quaternion as ThreeQuaternion} from "three";
+import Vector3 from "./Vector3";
 
 interface Vector3Like {
     x: number,
@@ -28,12 +29,18 @@ export default class Quaternion {
 
     clone(): Quaternion
 
+    random(random?:()=>number):void
+
     equals(other: { x: number, y: number, z: number, w: number }): boolean
 
+    roughlyEquals(other: { x: number, y: number, z: number, w: number }, tolerance?: number): boolean
+
     slerp(other: Quaternion, t: number): void
 
     normalize(): void
 
+    length():number
+
     __setFromEuler(x: number, y: number, z: number, order?: string): void
 
     setFromRotationMatrix(m: Matrix4): void
@@ -54,6 +61,8 @@ export default class Quaternion {
 
     fromAxisAngle(axis: Vector3Like, angle: number): void
 
+    toAxisAngle(axis: Vector3):number
+
     computeTwistAngle(axis: Vector3Like): number
 
     multiplyQuaternions(a: Quaternion, b: Quaternion): void
@@ -69,4 +78,6 @@ export default class Quaternion {
     writeToArray(array: ArrayLike<number>, offset?: number): void
 
     asArray(): number[]
+
+    static readonly identity:Quaternion
 }

package/src/core/geom/Quaternion.js

@@ -136,15 +136,16 @@ class Quaternion {
 
         up.crossVectors(forward, right);
 
-        var m00 = right.x;
-        var m01 = right.y;
-        var m02 = right.z;
-        var m10 = up.x;
-        var m11 = up.y;
-        var m12 = up.z;
-        var m20 = forward.x;
-        var m21 = forward.y;
-        var m22 = forward.z;
+        // construct partial transform matrix
+        const m00 = right.x;
+        const m01 = right.y;
+        const m02 = right.z;
+        const m10 = up.x;
+        const m11 = up.y;
+        const m12 = up.z;
+        const m20 = forward.x;
+        const m21 = forward.y;
+        const m22 = forward.z;
 
 
         const num8 = (m00 + m11) + m22;
@@ -159,22 +160,29 @@ class Quaternion {
             _y = (m20 - m02) * num;
             _z = (m01 - m10) * num;
         } else if ((m00 >= m11) && (m00 >= m22)) {
-            var num7 = Math.sqrt(((1 + m00) - m11) - m22);
-            var num4 = 0.5 / num7;
+
+            const num7 = Math.sqrt(((1 + m00) - m11) - m22);
+            const num4 = 0.5 / num7;
+
             _x = 0.5 * num7;
             _y = (m01 + m10) * num4;
             _z = (m02 + m20) * num4;
             _w = (m12 - m21) * num4;
+
         } else if (m11 > m22) {
-            var num6 = Math.sqrt(((1 + m11) - m00) - m22);
-            var num3 = 0.5 / num6;
+
+            const num6 = Math.sqrt(((1 + m11) - m00) - m22);
+            const num3 = 0.5 / num6;
+
             _x = (m10 + m01) * num3;
             _y = 0.5 * num6;
             _z = (m21 + m12) * num3;
             _w = (m20 - m02) * num3;
         } else {
-            var num5 = Math.sqrt(((1 + m22) - m00) - m11);
-            var num2 = 0.5 / num5;
+
+            const num5 = Math.sqrt(((1 + m22) - m00) - m11);
+            const num2 = 0.5 / num5;
+
             _x = (m20 + m02) * num2;
             _y = (m21 + m12) * num2;
             _z = 0.5 * num5;
@@ -359,9 +367,9 @@ class Quaternion {
     toAxisAngle(axis) {
         const rad = Math.acos(this.w) * 2.0;
 
-        const s = Math.sin(rad / 2.0);
+        const s = Math.sin(rad * 0.5);
 
-        if (s > EPSILON) {
+        if (Math.abs(s) > EPSILON) {
             axis.set(
                 this.x / s,
                 this.y / s,
@@ -378,7 +386,8 @@ class Quaternion {
         let l = this.length();
 
         if (l < EPSILON) {
-            // use identity
+            // Quaternion has close to 0 length
+            // use identity, avoid division by 0
             this.set(0, 0, 0, 1);
         } else {
             const m = 1 / l;
@@ -1131,17 +1140,17 @@ class Quaternion {
         m31, m32, m33
     ) {
 
-        assert.notNaN(m11,'m11');
-        assert.notNaN(m12,'m12');
-        assert.notNaN(m13,'m13');
+        assert.notNaN(m11, 'm11');
+        assert.notNaN(m12, 'm12');
+        assert.notNaN(m13, 'm13');
 
-        assert.notNaN(m21,'m21');
-        assert.notNaN(m22,'m22');
-        assert.notNaN(m23,'m23');
+        assert.notNaN(m21, 'm21');
+        assert.notNaN(m22, 'm22');
+        assert.notNaN(m23, 'm23');
 
-        assert.notNaN(m31,'m31');
-        assert.notNaN(m32,'m32');
-        assert.notNaN(m33,'m33');
+        assert.notNaN(m31, 'm31');
+        assert.notNaN(m32, 'm32');
+        assert.notNaN(m33, 'm33');
 
 
         const trace = m11 + m22 + m33;

package/src/core/geom/Quaternion.spec.js

@@ -1,5 +1,6 @@
 import Quaternion from "./Quaternion.js";
 import Vector3 from "./Vector3.js";
+import { decode_octahedron_to_unit } from "./3d/normal/octahedron/decode_octahedron_to_unit.js";
 
 /**
  *
@@ -260,3 +261,143 @@ test('computeTwistAngle', () => {
     expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp * 3);
 
 });
+
+test("numeric(array) accessors", () => {
+
+    const q = new Quaternion();
+
+    q[0] = 3;
+    q[1] = -7;
+    q[2] = 11;
+    q[3] = -13;
+
+    expect(q[0]).toEqual(3);
+    expect(q.x).toEqual(3);
+
+    expect(q[1]).toEqual(-7);
+    expect(q.y).toEqual(-7);
+
+    expect(q[2]).toEqual(11);
+    expect(q.z).toEqual(11);
+
+    expect(q[3]).toEqual(-13);
+    expect(q.w).toEqual(-13);
+});
+
+test("forward lookRotation produces identity quaternion ", () => {
+
+    const q = new Quaternion(1, 3, 4, -7);
+
+    q.lookRotation(Vector3.forward, Vector3.up);
+
+    expect(q.roughlyEquals(Quaternion.identity)).toBe(true);
+
+});
+
+test("lookRotation when FORWARD and UP are the same vectors ", () => {
+
+    const q = new Quaternion(1, 3, 4, -7);
+
+    q.lookRotation(Vector3.forward, Vector3.forward);
+
+    const vec = Vector3.forward.clone();
+
+    vec.applyQuaternion(q);
+
+    expect(vec.roughlyEquals(Vector3.forward, 0.001)).toBe(true);
+});
+
+test("check lookRotation rotations on octahedron points", () => {
+
+    const q = new Quaternion(1, 3, 4, -7);
+
+    const direction_vector_forward_array = [];
+
+    const direction_vector_forward = new Vector3();
+
+    const direction_vector_up_array = [];
+
+    const direction_vector_up = new Vector3();
+
+    const rotation_vector = new Vector3();
+
+    const GRID_SIZE = 9;
+
+    for (let i0 = 0; i0 < GRID_SIZE; i0++) {
+        for (let j0 = 0; j0 < GRID_SIZE; j0++) {
+
+            const u0 = i0 / (GRID_SIZE - 1);
+            const v0 = j0 / (GRID_SIZE - 1);
+
+            // sample direction for FORWARD vector
+            decode_octahedron_to_unit(direction_vector_forward_array, 0, u0, v0);
+            direction_vector_forward.readFromArray(direction_vector_forward_array);
+
+
+            for (let i1 = 0; i1 < GRID_SIZE; i1++) {
+                for (let j1 = 0; j1 < GRID_SIZE; j1++) {
+
+                    const u1 = i1 / (GRID_SIZE - 1);
+                    const v1 = j1 / (GRID_SIZE - 1);
+
+                    // sample direction for UP vector
+                    decode_octahedron_to_unit(direction_vector_up_array, 0, u1, v1);
+                    direction_vector_up.readFromArray(direction_vector_up_array);
+
+                    // obtain quaternion
+                    q.lookRotation(direction_vector_forward, direction_vector_up);
+
+                    // verify that a vector transformed via this quaternion would produce the same direction as the look direciton
+                    rotation_vector.copy(Vector3.forward);
+
+                    rotation_vector.applyQuaternion(q);
+
+                    expect(rotation_vector.roughlyEquals(direction_vector_forward, 0.001)).toBe(true);
+
+                }
+            }
+
+        }
+    }
+});
+
+test("random produces valid normalized quaternion", () => {
+
+    const q = new Quaternion();
+
+    q.random(() => 0);
+
+    expect(q.length()).toBeCloseTo(1);
+
+});
+
+test("toAxisAngle on identity", () => {
+    const q = new Quaternion();
+
+    const axis = new Vector3();
+
+    const angle = q.toAxisAngle(axis);
+
+    expect(angle).toBeCloseTo(0)
+});
+
+test("normalizing quaternion of 0 length produces non-NaN result", () => {
+    const q = new Quaternion(0, 0, 0, 0);
+
+    q.normalize();
+
+    expect(q.x).not.toBeNaN();
+    expect(q.y).not.toBeNaN();
+    expect(q.z).not.toBeNaN();
+    expect(q.w).not.toBeNaN();
+
+    expect(q.length()).toBeCloseTo(1);
+});
+
+test("angleTo between identical quaternions should be 0", () => {
+
+    const a = new Quaternion();
+    const b = new Quaternion();
+
+    expect(a.angleTo(b)).toBeCloseTo(0);
+});

package/src/core/geom/Vector2.d.ts

@@ -35,6 +35,10 @@ export default class Vector2 {
 
     clone(): Vector2
 
+    equals(other: Vector2): boolean
+
+    roughlyEquals(other: Vector2, tolerance?: number): boolean
+
     distanceTo(other: Vector2): number
 
     isZero(): boolean
@@ -43,5 +47,5 @@ export default class Vector2 {
 
     writeToArray(array: ArrayLike<number>, offset?: number): void
 
-    asArray():number[]
+    asArray(): number[]
 }

package/src/core/geom/Vector2.js

@@ -9,6 +9,8 @@ import { clamp } from "../math/clamp.js";
 import { lerp } from "../math/lerp.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
+import { EPSILON } from "../math/EPSILON.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
 
 class Vector2 {
     /**
@@ -588,6 +590,28 @@ class Vector2 {
         return this.x === other.x && this.y === other.y;
     }
 
+    /**
+     *
+     * @param {Vector2} other
+     * @param {number} [tolerance]
+     * @return {boolean}
+     */
+    roughlyEquals(other, tolerance) {
+        return this._roughlyEquals(other.x, other.y,  tolerance);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} [tolerance] acceptable deviation
+     * @return {boolean}
+     */
+    _roughlyEquals(x, y, tolerance = EPSILON) {
+        return epsilonEquals(this.x, x, tolerance)
+            && epsilonEquals(this.y, y, tolerance);
+    }
+
     get 0() {
         return this.x;
     }

package/src/core/geom/Vector3.d.ts

@@ -69,10 +69,16 @@ export default class Vector3 implements Vector3Like {
 
     clone(): Vector3
 
+    equals(other: Vector3Like): boolean
+
+    roughlyEquals(other: Vector3Like, tolerance?: number): boolean
+
     normalize(): void
 
     length(): number
 
+    lengthSqr(): number
+
     lerpVectors(a: Vector3Like, b: Vector3Like, fraction: number): void
 
     distanceTo(other: Vector3Like): number