@woosh/meep-engine 2.49.9 → 2.50.0

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,6 +69,10 @@ export default class Vector3 implements Vector3Like {
 
     clone(): Vector3
 
+    equals(other:Vector3Like):boolean
+
+    roughlyEquals(other:Vector3Like,tolerance?:number):boolean
+
     normalize(): void
 
     length(): number

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

@@ -45,3 +45,63 @@ test('addVectors', () => {
     expect(ut.y).toBe(14);
     expect(ut.z).toBe(18);
 });
+
+test("equals", () => {
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, -2, 3)))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(5, -2, 3)))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, 5, 3)))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, -2, 5)))
+        .toBe(false);
+});
+
+test("roughlyEquals", () => {
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3), 0))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1.01, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(0.99, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(0.89, -2, 3), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1.11, -2, 3), 0.1))
+        .toBe(false);
+
+    // Y
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2.01, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -1.99, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2.11, 3), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -1.89, 3), 0.1))
+        .toBe(false);
+
+    // Z
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.01), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 2.99), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 2.89), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.11), 0.1))
+        .toBe(false);
+});

package/src/core/graph/GraphUtils.js

@@ -3,7 +3,9 @@
  */
 
 
-import { computeLine2Intersection } from "../geom/2d/LineSegment2.js";
+import {
+    line_segment_compute_line_segment_intersection_vectors_array_2d
+} from "../geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js";
 
 const Utils = {};
 
@@ -155,7 +157,7 @@ function graph2paths(graph, thickness) {
         const l = edges.length;
         for (; i < l; i++) {
             const edge = edges[i];
-            if (computeLine2Intersection(from, to, edge.first, edge.second)) {
+            if (line_segment_compute_line_segment_intersection_vectors_array_2d(from, to, edge.first, edge.second)) {
                 return true;
             }
         }

package/src/core/graph/layout/CircleLayout.js

@@ -6,7 +6,6 @@
 import { assert } from "../../assert.js";
 import Circle from "../../geom/2d/circle/Circle.js";
 import AABB2 from "../../geom/2d/aabb/AABB2.js";
-import { line2SegmentsIntersect } from "../../geom/2d/LineSegment2.js";
 import Vector2, { v2_distance } from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
@@ -14,6 +13,9 @@ import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js"
 import { Connection } from "./Connection.js";
 import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
 import { applyCentralGravityAABB2 } from "./box/applyCentralGravityAABB2.js";
+import {
+    line_segment_line_segment_intersection_exists_2d
+} from "../../geom/2d/line/line_segment_line_segment_intersection_exists_2d.js";
 
 
 /**
@@ -364,7 +366,7 @@ function computeNumberOfCrossOvers(edges, numEdges) {
             const b0 = e1.source;
             const b1 = e1.target;
 
-            if (line2SegmentsIntersect(
+            if (line_segment_line_segment_intersection_exists_2d(
                 a0.x, a0.y,
                 a1.x, a1.y,
                 b0.x, b0.y,

package/src/core/math/vector_nd_dot.js

@@ -0,0 +1,16 @@
+/**
+ * N-dimensional vector dot product
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} n number of dimensions
+ * @return {number}
+ */
+export function vector_nd_dot(a, b, n) {
+    let result = 0;
+
+    for (let i = 0; i < n; i++) {
+        result += a[i] * b[i]
+    }
+
+    return result;
+}

package/src/core/math/{normalizeArrayVector.js → vector_nd_normalize.js}

@@ -1,10 +1,10 @@
 /**
  * Assuming the input is an N-dimension vector, normalizes the vector to magnitude of 1
- * @param {number[]|Float32Array} result
- * @param {number[]|Float32Array} data
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number[]|Float32Array|Float64Array} data
  * @param {number} [length] number of dimensions
  */
-export function normalizeArrayVector(result, data, length = data.length) {
+export function vector_nd_normalize(result, data, length = data.length) {
 
     let magnitude2 = 0;
 

package/src/core/math/{normalizeArrayVector.spec.js → vector_nd_normalize.spec.js}

@@ -1,15 +1,15 @@
-import { normalizeArrayVector } from "./normalizeArrayVector.js";
+import { vector_nd_normalize } from "./vector_nd_normalize.js";
 
 test("1d vector normalization", () => {
     const v = [7];
 
-    normalizeArrayVector(v, v, 1);
+    vector_nd_normalize(v, v, 1);
 
     expect(v[0]).toBeCloseTo(1);
 
     v[0] = -13;
 
-    normalizeArrayVector(v, v, 1);
+    vector_nd_normalize(v, v, 1);
 
     expect(v[0]).toBeCloseTo(-1);
 });

package/src/core/process/PromiseWatcher.spec.js

@@ -16,7 +16,7 @@ function trigger() {
     return {
         promise,
         reject(r) {
-            _reject(r)
+            setTimeout(() => _reject(r), 1);
         },
         resolve(v) {
             _resolve(v);

package/src/engine/animation/curve/compression/downsample_float_array_curve_by_error.js

@@ -6,7 +6,7 @@ import { lerp } from "../../../../core/math/lerp.js";
 import { min3 } from "../../../../core/math/min3.js";
 import { max3 } from "../../../../core/math/max3.js";
 import { downsample_float_array } from "./downsample_float_array.js";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOrTwo.js";
 
 /**