@woosh/meep-engine 2.37.18 → 2.37.19

package/core/assert.js

@@ -1,5 +1,5 @@
-import { isTypedArray } from "./json/JsonUtils.js";
 import { isArrayEqualStrict } from "./collection/array/isArrayEqualStrict.js";
+import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
 
 function equal(a, b, m) {
     assert(a === b, m) // eslint-disable-line eqeqeq

package/core/collection/array/typed/isTypedArray.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param o
+ * @returns {boolean}
+ */
+function isTypedArray(o) {
+    return (
+        o instanceof Int8Array ||
+        o instanceof Uint8Array ||
+        o instanceof Uint8ClampedArray ||
+        o instanceof Int16Array ||
+        o instanceof Uint16Array ||
+        o instanceof Int32Array ||
+        o instanceof Uint32Array ||
+        o instanceof Float32Array ||
+        o instanceof Float64Array
+    );
+}
+
+export { isTypedArray };

package/core/collection/array/typedArrayToDataType.js

@@ -10,6 +10,7 @@ export function typedArrayToDataType(v) {
 
     switch (ctor) {
         case Uint8Array:
+        case Uint8ClampedArray:
             return DataType.Uint8;
         case Uint16Array:
             return DataType.Uint16;

package/core/collection/table/RowFirstTable.js

@@ -6,6 +6,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
+import { array_copy } from "../array/copyArray.js";
 
 /**
  *
@@ -414,6 +415,39 @@ RowFirstTable.prototype.setRow = function (index, record) {
     this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
 }
 
+/**
+ * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
+ */
+RowFirstTable.prototype.reverse_rows = function () {
+    const bpr = this.bytesPerRecord;
+    const copy_buffer = new Uint8Array(bpr);
+
+    const buffer = this.data;
+    const wrapper = new Uint8Array(buffer);
+
+    const length = this.length;
+
+    if (length <= 1) {
+        // need at least 2 rows for reversal to make any change
+        return;
+    }
+
+    const last_row_index = length - 1;
+
+
+    const traversal_limit = last_row_index >>> 1;
+    for (let i = 0; i <= traversal_limit; i++) {
+        const address = i * bpr;
+        array_copy(wrapper, address, copy_buffer, 0, bpr);
+
+        const swap_index = last_row_index - i;
+        const swap_address = swap_index * bpr;
+
+        wrapper.copyWithin(address, swap_address, swap_address + bpr)
+        wrapper.set(copy_buffer, swap_address);
+    }
+};
+
 /**
  * clear out all the data and free memory
  */

package/core/collection/table/RowFirstTable.spec.js

@@ -223,7 +223,65 @@ test('copy', () => {
     a.addRow([-11.3, 13]);
 
     const b = new RowFirstTable(spec);
-b.copy(a);
+    b.copy(a);
 
 
 });
+
+
+test('reverse_rows 3 rows (odd number)', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+    a.addRow([1]);
+    a.addRow([2]);
+    a.addRow([3]);
+
+    a.reverse_rows();
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(3);
+    expect(a.readCellValue(1, 0)).toBeCloseTo(2);
+    expect(a.readCellValue(2, 0)).toBeCloseTo(1);
+});
+
+test('reverse_rows 2 rows', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+    a.addRow([3.1, 7]);
+    a.addRow([-11.3, 13]);
+
+    a.reverse_rows();
+
+    expect(a.readCellValue(1, 0)).toBeCloseTo(3.1);
+    expect(a.readCellValue(1, 1)).toBeCloseTo(7);
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(-11.3);
+    expect(a.readCellValue(0, 1)).toBeCloseTo(13);
+});
+
+test('reverse_rows 1 row', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+
+    a.addRow([3.1, 7]);
+    a.reverse_rows();
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(3.1);
+    expect(a.readCellValue(0, 1)).toBeCloseTo(7);
+});
+
+test('reverse_rows empty', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+
+    a.reverse_rows();
+
+    expect(a.length).toBe(0);
+});

package/core/color/Color.js

@@ -9,6 +9,7 @@ import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";
+import { rgb2hex } from "./rgb2hex.js";
 
 /**
  * @class
@@ -346,6 +347,19 @@ export class Color {
         this.setRGB(r / 255, g / 255, b / 255);
     }
 
+    /**
+     * Returns color in CSS hex color format
+     * @example #FF0000
+     * @returns {string}
+     */
+    toHex() {
+        return '#' + rgb2hex(
+            Math.round(this.r),
+            Math.round(this.g),
+            Math.round(this.b)
+        );
+    }
+
     /**
      *
      * @param {Color} other

package/core/color/rgb2hex.js

@@ -1,5 +1,5 @@
 function dec2hex(c) {
-    const hex = c.toString(16);
+    const hex = Math.round(c).toString(16);
     return hex.length === 1 ? "0" + hex : hex;
 }
 

package/core/events/signal/Signal.spec.js

@@ -147,3 +147,19 @@ test("handler context is properly setup during dispatch", () => {
 
     expect(handler).toHaveBeenCalled();
 });
+
+test("handlers should be executed in the order in which they are added", () => {
+    const signal = new Signal();
+
+    const marks = [];
+
+    const write_1 = jest.fn(() => marks.push(1));
+    const write_2 = jest.fn(() => marks.push(2));
+
+    signal.add(write_1);
+    signal.add(write_2);
+
+    signal.send0();
+
+    expect(marks).toEqual([1, 2]);
+});

package/core/geom/Quaternion.d.ts

@@ -24,4 +24,9 @@ export default class Quaternion {
     setFromRotationMatrix(m: Matrix4): void
 
     decodeFromUint32(uint: number): void
+
+
+    toEulerAnglesXYZ(v3: { set(x: number, y: number, z: number): any }): void
+
+    fromEulerAnglesXYZ(x: number, y: number, z: number): void
 }

package/core/geom/Quaternion.js

@@ -7,9 +7,8 @@ import { Matrix4 as ThreeMatrix4 } from "three";
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
-import { copysign } from "../math/copysign.js";
 import { lerp } from "../math/lerp.js";
-import { EPSILON, epsilonEquals, PI2, PI_HALF } from "../math/MathUtils.js";
+import { EPSILON, epsilonEquals, PI2 } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
 import { v3_dot } from "./v3_dot.js";
 
@@ -503,84 +502,33 @@ class Quaternion {
 
         // http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
 
-        const cos = Math.cos;
-        const sin = Math.sin;
-
-        const half_x = x * 0.5;
-        const half_y = y * 0.5;
-        const half_z = z * 0.5;
-
-        const c1 = cos(half_x);
-        const c2 = cos(half_y);
-        const c3 = cos(half_z);
-
-        const s1 = sin(half_x);
-        const s2 = sin(half_y);
-        const s3 = sin(half_z);
-
         if (order === 'XYZ') {
 
-            return this.set(
-                s1 * c2 * c3 + c1 * s2 * s3,
-                c1 * s2 * c3 - s1 * c2 * s3,
-                c1 * c2 * s3 + s1 * s2 * c3,
-                c1 * c2 * c3 - s1 * s2 * s3
-            );
+            this.fromEulerAnglesXYZ(x, y, z);
 
         } else if (order === 'YXZ') {
 
-
-            return this.set(
-                s1 * c2 * c3 + c1 * s2 * s3,
-                c1 * s2 * c3 - s1 * c2 * s3,
-                c1 * c2 * s3 - s1 * s2 * c3,
-                c1 * c2 * c3 + s1 * s2 * s3
-            );
-
-            // return this.set(
-            //     c1 * s2 * c3 + s1 * c2 * s3,
-            //     s1 * c2 * c3 - c1 * s2 * s3,
-            //     c1 * c2 * s3 - s1 * s2 * c3,
-            //     c1 * c2 * c3 + s1 * s2 * s3
-            // );
+            this.fromEulerAnglesYXZ(x, y, z);
 
         } else if (order === 'ZXY') {
 
-            return this.set(
-                s1 * c2 * c3 - c1 * s2 * s3,
-                c1 * s2 * c3 + s1 * c2 * s3,
-                c1 * c2 * s3 + s1 * s2 * c3,
-                c1 * c2 * c3 - s1 * s2 * s3
-            );
+            this.fromEulerAnglesZXY(x, y, z);
 
         } else if (order === 'ZYX') {
 
-            return this.set(
-                s1 * c2 * c3 - c1 * s2 * s3,
-                c1 * s2 * c3 + s1 * c2 * s3,
-                c1 * c2 * s3 - s1 * s2 * c3,
-                c1 * c2 * c3 + s1 * s2 * s3
-            );
+            this.fromEulerAnglesZYX(x, y, z);
 
         } else if (order === 'YZX') {
 
-            return this.set(
-                s1 * c2 * c3 + c1 * s2 * s3,
-                c1 * s2 * c3 + s1 * c2 * s3,
-                c1 * c2 * s3 - s1 * s2 * c3,
-                c1 * c2 * c3 - s1 * s2 * s3
-            );
+            this.fromEulerAnglesYZX(x, y, z);
 
         } else if (order === 'XZY') {
 
-            return this.set(
-                s1 * c2 * c3 - c1 * s2 * s3,
-                c1 * s2 * c3 - s1 * c2 * s3,
-                c1 * c2 * s3 + s1 * s2 * c3,
-                c1 * c2 * c3 + s1 * s2 * s3
-            );
+            this.fromEulerAnglesXZY(x, y, z);
 
         }
+
+        return this;
     }
 
     /**
@@ -599,9 +547,9 @@ class Quaternion {
         const y2 = y * y;
         const z2 = z * z;
 
-        const psi = Math.atan2(-2 * (x * w - y * z), (w2 - x2 - y2 + z2));
+        const psi = Math.atan2(2 * (x * w - y * z), (w2 - x2 - y2 + z2));
         const theta = Math.asin(2 * (x * z + y * w));
-        const phi = Math.atan2(-2 * (z * w - x * y), (w2 + x2 - y2 - z2));
+        const phi = Math.atan2(2 * (z * w - x * y), (w2 + x2 - y2 - z2));
 
         result.set(psi, theta, phi);
     }
@@ -727,64 +675,75 @@ class Quaternion {
     }
 
     /**
-     * Writes Pitch(Y), Yaw(Z), Roll(X) to a given vector
-     * @param {Vector3} result
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
      */
-    toEulerAngles2(result) {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
+    fromEulerAngles(x, y, z) {
+        return this.fromEulerAnglesXYZ(x, y, z);
+    }
 
-        const yy = y * y;
-        const xx = x * x;
-        const zz = z * z;
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesXYZ(x, y, z) {
+        const half_x = x * 0.5;
+        const half_y = y * 0.5;
+        const half_z = z * 0.5;
 
-        // roll (x-axis rotation)
-        const sinr_cosp = +2.0 * (w * x + y * z);
-        const cosr_cosp = +1.0 - 2.0 * (xx + yy);
-        const roll = Math.atan2(sinr_cosp, cosr_cosp);
+        const sin = Math.sin;
+        const cos = Math.cos;
 
-        let pitch;
-        // pitch (y-axis rotation)
-        const sinp = +2.0 * (w * y - z * x);
-        if (Math.abs(sinp) >= 1) {
-            pitch = copysign(Math.PI / 2, sinp); // use 90 degrees if out of range
-        } else {
-            pitch = Math.asin(sinp);
-        }
+        const s1 = sin(half_x);
+        const s2 = sin(half_y);
+        const s3 = sin(half_z);
 
-        // yaw (z-axis rotation)
-        const siny_cosp = +2.0 * (w * z + x * y);
-        const cosy_cosp = +1.0 - 2.0 * (yy + zz);
-        const yaw = Math.atan2(siny_cosp, cosy_cosp);
+        const c1 = cos(half_x);
+        const c2 = cos(half_y);
+        const c3 = cos(half_z);
+
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 + s1 * s2 * c3;
+        const _w = c1 * c2 * c3 - s1 * s2 * s3;
 
-        result.set(roll, pitch, yaw);
+        this.set(_x, _y, _z, _w);
     }
 
     /**
      * XYZ order
      * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
      * @param {number} x angle in X axis in radians
      * @param {number} y angle in Y axis in radians
      * @param {number} z angle in Z axis in radians
      */
-    fromEulerAngles(x, y, z) {
+    fromEulerAnglesYXZ(x, y, z) {
         const scaled_x = x * 0.5;
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const sx = Math.sin(scaled_x);
-        const cx = Math.cos(scaled_x);
-        const sy = Math.sin(scaled_y);
-        const cy = Math.cos(scaled_y);
-        const sz = Math.sin(scaled_z);
-        const cz = Math.cos(scaled_z);
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
 
-        const _x = sx * cy * cz - cx * sy * sz;
-        const _y = cx * sy * cz + sx * cy * sz;
-        const _z = cx * cy * sz - sx * sy * cz;
-        const _w = cx * cy * cz + sx * sy * sz;
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 - s1 * s2 * c3;
+        const _w = c1 * c2 * c3 + s1 * s2 * s3;
 
         this.set(_x, _y, _z, _w);
     }
@@ -798,7 +757,7 @@ class Quaternion {
      * @param {number} y angle in Y axis in radians
      * @param {number} z angle in Z axis in radians
      */
-    fromEulerAnglesXYZ(x, y, z) {
+    fromEulerAnglesZXY(x, y, z) {
         const scaled_x = x * 0.5;
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
@@ -811,8 +770,8 @@ class Quaternion {
         const c2 = Math.cos(scaled_y);
         const c3 = Math.cos(scaled_z);
 
-        const _x = s1 * c2 * c3 + c1 * s2 * s3;
-        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _x = s1 * c2 * c3 - c1 * s2 * s3;
+        const _y = c1 * s2 * c3 + s1 * c2 * s3;
         const _z = c1 * c2 * s3 + s1 * s2 * c3;
         const _w = c1 * c2 * c3 - s1 * s2 * s3;
 
@@ -820,48 +779,93 @@ class Quaternion {
     }
 
     /**
-     * Writes Pitch(Y), Yaw(Z), Roll(X) to a given vector
-     * @source http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/
-     * @param {Vector3} result
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
      */
-    toEulerAngles(result) {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
+    fromEulerAnglesZYX(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
 
-        const sqw = w * w;
-        const sqx = x * x;
-        const sqy = y * y;
-        const sqz = z * z;
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
 
-        const unit = sqx + sqy + sqz + sqw; // if normalised is one, otherwise is correction factor
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
 
-        const test = x * w - y * z;
+        const _x = s1 * c2 * c3 - c1 * s2 * s3;
+        const _y = c1 * s2 * c3 + s1 * c2 * s3;
+        const _z = c1 * c2 * s3 - s1 * s2 * c3;
+        const _w = c1 * c2 * c3 + s1 * s2 * s3;
 
+        this.set(_x, _y, _z, _w);
+    }
 
-        let yaw, pitch, roll;
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesYZX(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
 
-        if (test > 0.4995 * unit) { // singularity at north pole
-            yaw = 2 * Math.atan2(y, x);
-            pitch = PI_HALF;
-            roll = 0;
-        } else if (test < -0.4995 * unit) { // singularity at south pole
-            yaw = -2 * Math.atan2(y, x);
-            pitch = -PI_HALF;
-            roll = 0;
-        } else {
-            yaw = Math.atan2(2 * x * w + 2 * y * z, 1 - 2 * (sqz + sqw));
-            pitch = Math.asin(2 * (x * z - w * y));
-            roll = Math.atan2(2 * x * y - 2 * z * w, 1 - 2 * (sqy + sqz))
-        }
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
+
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 + s1 * c2 * s3;
+        const _z = c1 * c2 * s3 - s1 * s2 * c3;
+        const _w = c1 * c2 * c3 - s1 * s2 * s3;
+
+        this.set(_x, _y, _z, _w);
+    }
+
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesXZY(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
 
-        //normalize angles
-        yaw = normalizeAngle(yaw);
-        pitch = normalizeAngle(pitch);
-        roll = normalizeAngle(roll);
+        const _x = s1 * c2 * c3 - c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 + s1 * s2 * c3;
+        const _w = c1 * c2 * c3 + s1 * s2 * s3;
 
-        result.set(pitch, yaw, roll);
+        this.set(_x, _y, _z, _w);
     }
 
     /**
@@ -1204,6 +1208,17 @@ class Quaternion {
         this.set(_x, _y, _z, _w);
     }
 
+    /**
+     * @see https://github.com/gareth-cross/quat/blob/master/include/quaternion.hpp
+     * TODO implement
+     * @param {Quaternion} a
+     * @param {Quaternion} b
+     * @param {number} t
+     */
+    quaternionsInterpolateRungeKutta4(a, b, t) {
+        throw new Error('Not Implemented');
+    }
+
     /**
      *
      * @param {function} handler

package/core/geom/Quaternion.spec.js

@@ -162,8 +162,8 @@ test('to/from euler YXZ consistency', () => {
 
         const u = new Vector3();
 
-        r.__setFromEuler(x, y, z, 'YXZ');
-        r.toEulerAnglesYXZ(u);
+        r.fromEulerAnglesXYZ(x, y, z);
+        r.toEulerAnglesXYZ(u);
 
         expect(u.x).toBeCloseTo(x);
         expect(u.y).toBeCloseTo(y);
@@ -177,4 +177,49 @@ test('to/from euler YXZ consistency', () => {
     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.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]);
+
+
 });