@woosh/meep-engine 2.110.13 → 2.110.15

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

@@ -1,429 +0,0 @@
-import { DEG_TO_RAD } from "../math/DEG_TO_RAD.js";
-import { decode_octahedron_to_unit } from "./3d/normal/octahedron/decode_octahedron_to_unit.js";
-import Quaternion from "./Quaternion.js";
-import Vector3 from "./Vector3.js";
-
-/**
- *
- * @param {Quaternion} expected
- * @param {Quaternion} actual
- * @param {number} [numDigits]
- */
-function expectRoughlyEquals(actual, expected, numDigits = 2) {
-
-    expect(actual.x).toBeCloseTo(expected.x, numDigits);
-    expect(actual.y).toBeCloseTo(expected.y, numDigits);
-    expect(actual.z).toBeCloseTo(expected.z, numDigits);
-    expect(actual.w).toBeCloseTo(expected.w, numDigits);
-}
-
-test('equals', () => {
-    const a = new Quaternion(1, 2, 3, 4);
-
-    const b = new Quaternion(2, 2, 3, 4);
-    const c = new Quaternion(1, 3, 3, 4);
-    const d = new Quaternion(1, 2, 4, 4);
-    const e = new Quaternion(1, 2, 3, 3);
-
-    const f = new Quaternion(1, 2, 3, 4);
-
-    expect(a.equals(f)).toBe(true);
-
-    expect(a.equals(b)).toBe(false);
-    expect(a.equals(c)).toBe(false);
-    expect(a.equals(d)).toBe(false);
-    expect(a.equals(e)).toBe(false);
-});
-
-test('empty constructor', () => {
-    const q = new Quaternion();
-
-    expect(q.x).toBe(0);
-    expect(q.y).toBe(0);
-    expect(q.z).toBe(0);
-    expect(q.w).toBe(1);
-});
-
-test('constructor parameter passing', () => {
-    const q = new Quaternion(3, 7, -1, 13);
-
-    expect(q.x).toBe(3);
-    expect(q.y).toBe(7);
-    expect(q.z).toBe(-1);
-    expect(q.w).toBe(13);
-});
-
-test('multiply quaternions', () => {
-    const a = new Quaternion(1, 2, 3, 4);
-
-    const b = new Quaternion(5, 6, 7, 8);
-
-    const c = new Quaternion();
-
-    c.multiplyQuaternions(a, b);
-
-    expect(c.toJSON()).toEqual({
-        x: 24,
-        y: 48,
-        z: 48,
-        w: -6
-    });
-});
-
-test('fromUnitVectors', () => {
-    const q = new Quaternion();
-
-    const v = new Vector3();
-
-    function check(v0, v1) {
-
-        q.fromUnitVectors(v0, v1);
-
-        v.copy(v0);
-
-        v.applyQuaternion(q);
-
-        expect(v.roughlyEquals(v1)).toBe(true);
-    }
-
-    check(Vector3.up, Vector3.up);
-    check(Vector3.down, Vector3.down);
-    check(Vector3.left, Vector3.left);
-    check(Vector3.right, Vector3.right);
-    check(Vector3.forward, Vector3.forward);
-    check(Vector3.back, Vector3.back);
-
-    // Check axis-aligned 90deg rotations
-    check(Vector3.up, Vector3.forward);
-    check(Vector3.up, Vector3.back);
-    check(Vector3.up, Vector3.left);
-    check(Vector3.up, Vector3.right);
-
-    check(Vector3.down, Vector3.forward);
-    check(Vector3.down, Vector3.back);
-    check(Vector3.down, Vector3.left);
-    check(Vector3.down, Vector3.right);
-
-    check(Vector3.left, Vector3.up);
-    check(Vector3.left, Vector3.down);
-    check(Vector3.left, Vector3.forward);
-    check(Vector3.left, Vector3.back);
-
-    check(Vector3.right, Vector3.up);
-    check(Vector3.right, Vector3.down);
-    check(Vector3.right, Vector3.forward);
-    check(Vector3.right, Vector3.back);
-
-    // check opposites
-    check(Vector3.forward, Vector3.back);
-    check(Vector3.back, Vector3.forward);
-
-    check(Vector3.up, Vector3.down);
-    check(Vector3.down, Vector3.up);
-
-    check(Vector3.left, Vector3.right);
-    check(Vector3.right, Vector3.left);
-
-});
-
-
-test('encoding to Uint32 consistency', () => {
-
-    function check(x, y, z, w) {
-        const a = new Quaternion(x, y, z, w);
-
-        a.normalize();
-
-        const b = new Quaternion(0, 0, 0, 1);
-
-        const encoded = a.encodeToUint32();
-
-        b.decodeFromUint32(encoded);
-
-        expectRoughlyEquals(b, a);
-    }
-
-    check(1, 2, 3, 4);
-    check(1, 2, 4, 3);
-    check(1, 4, 2, 3);
-    check(4, 1, 2, 3);
-    check(1, 3, 2, 4);
-    check(3, 1, 2, 4);
-
-    check(0, 0, 0, 1);
-    check(0, 0, 1, 0);
-    check(0, 1, 0, 0);
-    check(1, 0, 0, 0);
-});
-
-test('encoding to Uint32 and decoding identity correctly', () => {
-    const a = new Quaternion();
-    a.copy(Quaternion.identity);
-
-    const b = new Quaternion();
-
-    const encoded = a.encodeToUint32();
-
-    b.decodeFromUint32(encoded);
-
-    expect(b.toJSON()).toEqual(a.toJSON());
-});
-
-
-test('to/from euler YXZ consistency', () => {
-    function check(x, y, z) {
-
-        const r = new Quaternion();
-
-        const u = new Vector3();
-
-        r.fromEulerAnglesXYZ(x, y, z);
-        r.toEulerAnglesXYZ(u);
-
-        expect(u.x).toBeCloseTo(x);
-        expect(u.y).toBeCloseTo(y);
-        expect(u.z).toBeCloseTo(z);
-    }
-
-    check(0, 0, 1);
-    check(0, 1, 0);
-    check(0, 1, 1);
-    check(1, 0, 0);
-    check(1, 0, 1);
-    check(1, 1, 0);
-    check(1, 1, 1);
-
-    check(0, 0, -1);
-    check(0, -1, 0);
-    check(0, -1, -1);
-    check(-1, 0, 0);
-    check(-1, 0, -1);
-    check(-1, -1, 0);
-    check(-1, -1, -1);
-});
-
-
-/**
- * See https://www.andre-gaschler.com/rotationconverter/
- */
-test('toEulerAnglesXYZ', () => {
-
-    function check(quat, euler) {
-
-        const q = new Quaternion(...quat);
-
-        const r = new Vector3();
-        q.toEulerAnglesXYZ(r)
-
-        expect(r.x).toBeCloseTo(euler[0]);
-        expect(r.y).toBeCloseTo(euler[1]);
-        expect(r.z).toBeCloseTo(euler[2]);
-    }
-
-
-    check([0, 0, 0, 1], [0, 0, 0]);
-
-    check([0.4794255, 0, 0, 0.8775826], [1, 0, 0]);
-    check([0, 0.4794255, 0, 0.8775826], [0, 1, 0]);
-    check([0, 0, 0.4794255, 0.8775826], [0, 0, 1]);
-
-    check([0.4207355, 0.4207355, 0.2298488, 0.7701512], [1, 1, 0]);
-    check([0.2298488, 0.4207355, 0.4207355, 0.7701512], [0, 1, 1]);
-    check([0.4207355, -0.2298488, 0.4207355, 0.7701512], [1, 0, 1]);
-
-    check([0.5709415, 0.1675188, 0.5709415, 0.5656758], [1, 1, 1]);
-
-
-    check([-0.4794255, 0, 0, 0.8775826], [-1, 0, 0]);
-    check([0, -0.4794255, 0, 0.8775826], [0, -1, 0]);
-    check([0, 0, -0.4794255, 0.8775826], [0, 0, -1]);
-
-});
-
-test('computeTwistAngle', () => {
-    const q = new Quaternion();
-
-    q.fromAxisAngle(Vector3.up, 0);
-
-    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(0);
-
-    const hp = Math.PI * 0.5;
-
-    q.fromAxisAngle(Vector3.up, hp);
-
-    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp);
-
-    q.fromAxisAngle(Vector3.up, hp * 2);
-
-    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp * 2);
-
-    q.fromAxisAngle(Vector3.up, hp * 3);
-
-    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);
-});
-
-
-test("rotateTowards", () => {
-
-    const a = Quaternion.fromEulerAngles(30 * DEG_TO_RAD, 0, 0);
-    const b = Quaternion.fromEulerAngles(60 * DEG_TO_RAD, 0, 0);
-
-    const result = new Quaternion();
-
-    Quaternion.rotateTowards(result, a, b, 9 * DEG_TO_RAD);
-
-    expect(result.angleTo(a)).toBeCloseTo(9 * DEG_TO_RAD);
-
-    Quaternion.rotateTowards(result, a, b, 0);
-
-    expect(result.equals(a)).toBe(true);
-
-    Quaternion.rotateTowards(result, a, b, Infinity);
-
-    expect(result.equals(b)).toBe(true);
-
-    Quaternion.rotateTowards(result, a, b, -10);
-
-    expect(result.roughlyEquals(a)).toBe(true);
-});

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

@@ -1,74 +0,0 @@
-import Vector1 from "./Vector1.js";
-
-test("Set value and read it back", () => {
-    const v = new Vector1(1);
-
-    expect(v.getValue()).toBe(1);
-
-    v.set(7);
-
-    expect(v.getValue()).toBe(7);
-
-    v.set(0);
-
-    expect(v.getValue()).toBe(0);
-
-    v.set(-7);
-
-    expect(v.getValue()).toBe(-7);
-
-    //redundant operation, expected no change
-    v.set(-7);
-
-    expect(v.getValue()).toBe(-7);
-});
-
-test('JSON serialization consistency', () => {
-    const a = new Vector1(42);
-
-    const jA = a.toJSON();
-
-    const b = new Vector1();
-
-    b.fromJSON(jA);
-
-    expect(b.getValue()).toBe(a.getValue());
-});
-
-test("add Vector1", () => {
-    const a = new Vector1(3);
-
-    a.add(new Vector1(5));
-
-    expect(a.getValue()).toBe(8);
-
-    a.add(new Vector1(-5));
-
-    expect(a.getValue()).toBe(3);
-});
-
-test("multiply Vector1", () => {
-    const a = new Vector1(3);
-
-    a.multiply(new Vector1(-5));
-
-    expect(a.getValue()).toBe(-15);
-});
-
-test("Number interface", () => {
-    const a = new Vector1(7);
-
-    expect(a + 1).toBe(8);
-
-    expect(a > 0).toBe(true);
-
-    expect(a == 7).toBe(true);
-});
-
-test("toString", () => {
-    const a = new Vector1(3);
-
-    const s = a.toString();
-
-    expect(typeof s).toBe('string');
-});