@woosh/meep-engine 2.46.4 → 2.46.5

package/src/core/geom/Quaternion.js

@@ -0,0 +1,1857 @@
+/**
+ * Created by Alex on 10/03/14.
+ */
+
+
+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 { lerp } from "../math/lerp.js";
+import Vector3 from "./Vector3.js";
+import { v3_dot } from "./v3_dot.js";
+import { min2 } from "../math/min2.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
+import { EPSILON } from "../math/EPSILON.js";
+
+const matrix = new ThreeMatrix4();
+
+const forward = new Vector3();
+const up = new Vector3();
+const right = new Vector3();
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} fx
+ * @param {number} fy
+ * @param {number} fz
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz
+ */
+export function quat_array_from_look(out, fx, fy, fz, ux, uy, uz) {
+    forward.set(fx, fy, fz);
+    forward.normalize();
+
+    right._crossVectors(ux, uy, uz, forward.x, forward.y, forward.z);
+    right.normalize();
+
+    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;
+
+
+    const num8 = (m00 + m11) + m22;
+
+    let _x, _y, _z, _w;
+
+    if (num8 > 0) {
+        let num = Math.sqrt(num8 + 1);
+        _w = num * 0.5;
+        num = 0.5 / num;
+        _x = (m12 - m21) * num;
+        _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;
+        _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;
+        _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;
+        _x = (m20 + m02) * num2;
+        _y = (m21 + m12) * num2;
+        _z = 0.5 * num5;
+        _w = (m01 - m10) * num2;
+    }
+
+    out[0] = _x;
+    out[1] = _y;
+    out[2] = _z;
+    out[3] = _w;
+}
+
+/**
+ * just in case you need that function also
+ * @param {Vector3} axis
+ * @param {number} angle
+ * @param {Quaternion} result
+ */
+export function quat3_createFromAxisAngle(axis, angle, result) {
+    const halfAngle = angle * .5;
+    const s = Math.sin(halfAngle);
+    result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
+}
+
+class Quaternion {
+    /**
+     *
+     * @param {Number} [x=0]
+     * @param {Number} [y=0]
+     * @param {Number} [z=0]
+     * @param {Number} [w=1]
+     * @constructor
+     */
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+
+        /**
+         *
+         * @type {Number}
+         */
+        this.x = x;
+        /**
+         *
+         * @type {Number}
+         */
+        this.y = y;
+        /**
+         *
+         * @type {Number}
+         */
+        this.z = z;
+        /**
+         *
+         * @type {Number}
+         */
+        this.w = w;
+
+        this.onChanged = new Signal();
+    }
+
+    get 0() {
+        return this.x;
+    }
+
+    get 1() {
+        return this.y;
+    }
+
+    get 2() {
+        return this.z;
+    }
+
+    get 3() {
+        return this.w;
+    }
+
+    set 0(v) {
+        this.x = v;
+    }
+
+    set 1(v) {
+        this.y = v;
+    }
+
+    set 2(v) {
+        this.z = v;
+    }
+
+    set 3(v) {
+        this.w = v;
+    }
+
+    /**
+     *
+     * @param {number} fx forward vector
+     * @param {number} fy forward vector
+     * @param {number} fz forward vector
+     * @param {number} ux up vector
+     * @param {number} uy up vector
+     * @param {number} uz up vector
+     */
+    _lookRotation(fx, fy, fz, ux, uy, uz) {
+        forward.set(fx, fy, fz);
+        forward.normalize();
+
+        right._crossVectors(ux, uy, uz, forward.x, forward.y, forward.z);
+
+        if(right.lengthSq() === 0){
+            // up and forward are parallel
+
+            /*
+             adjust forward direction slightly
+             code take from : https://github.com/mrdoob/three.js/blob/88e8954b69377dad4ad1ceaf1a383f3536e88e5a/src/math/Matrix4.js#L304
+             */
+
+            if(Math.abs(uz) === 1){
+                forward.x += 0.001;
+            }else{
+                forward.z += 0.001;
+            }
+
+            forward.normalize();
+            right._crossVectors(ux,uy,uz, forward.x, forward.y, forward.z);
+
+        }
+
+        right.normalize();
+
+        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;
+
+
+        const num8 = (m00 + m11) + m22;
+
+        let _x, _y, _z, _w;
+
+        if (num8 > 0) {
+            let num = Math.sqrt(num8 + 1);
+            _w = num * 0.5;
+            num = 0.5 / num;
+            _x = (m12 - m21) * num;
+            _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;
+            _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;
+            _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;
+            _x = (m20 + m02) * num2;
+            _y = (m21 + m12) * num2;
+            _z = 0.5 * num5;
+            _w = (m01 - m10) * num2;
+        }
+
+        this.set(_x, _y, _z, _w);
+    }
+
+    /**
+     *
+     * @param {Vector3} vForward
+     * @param {Vector3} [vUp=Vector3.up]
+     *
+     * @source http://answers.unity3d.com/questions/467614/what-is-the-source-code-of-quaternionlookrotation.html
+     */
+    lookRotation(vForward, vUp = Vector3.up) {
+
+        this._lookRotation(vForward.x, vForward.y, vForward.z, vUp.x, vUp.y, vUp.z);
+    }
+
+    /**
+     *
+     * @param {Euler} euler
+     * @return {void|Quaternion|Euler}
+     * @private
+     */
+    __setThreeEuler(euler) {
+
+        this.__setRotationMatrix(matrix.elements);
+
+        return euler.setFromRotationMatrix(matrix);
+    }
+
+
+    /**
+     *
+     * @param {Quaternion} other
+     */
+    copyInverse(other) {
+        this.copy(other);
+        this.invert();
+    }
+
+    /**
+     * Calculates the inverse
+     */
+    invert() {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        const dot = x * x + y * y + z * z + w * w;
+
+        if (dot === 0) {
+            this.set(0, 0, 0, 0);
+            return;
+        }
+
+        const invDot = 1.0 / dot;
+
+        const _x = -x * invDot;
+        const _y = -y * invDot;
+        const _z = -z * invDot;
+        const _w = w * invDot;
+
+        this.set(_x, _y, _z, _w);
+    }
+
+    /**
+     * Returns angle between this orientation and another
+     * @param {Quaternion} other
+     * @return {number} angle in radians
+     */
+    angleTo(other) {
+        //compute inverse
+
+        const x0 = this.x;
+        const y0 = this.y;
+        const z0 = this.z;
+        const w0 = this.w;
+
+        const x1 = other.x;
+        const y1 = other.y;
+        const z1 = other.z;
+        const w1 = other.w;
+
+        const dot = x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0;
+
+        let ix, iy, iz, iw;
+
+        if (dot === 0) {
+            ix = 0;
+            iy = 0;
+            iz = 0;
+            iw = 0;
+        } else {
+
+            const invDot = 1.0 / dot;
+
+            ix = -x0 * invDot;
+            iy = -y0 * invDot;
+            iz = -z0 * invDot;
+            iw = w0 * invDot;
+        }
+
+        //compute resulting quaternion
+        const w = w1 * iw - x1 * ix - y1 * iy - z1 * iz;
+
+        const _w = clamp(w, -1, 1);
+
+        return Math.acos(_w) * 2;
+    }
+
+    /**
+     *
+     * @param {Vector3} axis
+     * @param {number} angle
+     */
+    fromAxisAngle(axis, angle) {
+        this._fromAxisAngle(axis.x, axis.y, axis.z, angle);
+    }
+
+    /**
+     *
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @param {number} angle
+     */
+    _fromAxisAngle(ax, ay, az, angle) {
+        const halfAngle = angle * 0.5;
+
+        const sinA2 = Math.sin(halfAngle);
+        const cosA2 = Math.cos(halfAngle);
+
+        const qx = ax * sinA2;
+        const qy = ay * sinA2;
+        const qz = az * sinA2;
+        const qw = cosA2;
+
+        //normalize
+        const length = Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw);
+
+        const m = 1 / length;
+
+        const x = qx * m;
+        const y = qy * m;
+        const z = qz * m;
+        const w = qw * m;
+
+        this.set(x, y, z, w);
+    }
+
+    /**
+     * @see https://stackoverflow.com/questions/3684269/component-of-a-quaternion-rotation-around-an-axis
+     * @param {Vector3} axis
+     * @param {Quaternion} swing
+     * @param {Quaternion} twist
+     */
+    computeSwingAndTwist(axis, swing, twist) {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        // perform projection of rotation onto axis
+        const d = v3_dot(x, y, z, axis.x, axis.y, axis.z);
+
+        const mag2 = (axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+
+        const m = d / mag2;
+
+        const px = axis.x * m;
+        const py = axis.y * m;
+        const pz = axis.z * m;
+
+        if (d < 0) {
+            // axis points in the opposite direction from calculated twist, invert all components
+            twist.set(-px, -py, -pz, -w);
+        } else {
+            twist.set(px, py, pz, w);
+
+        }
+
+        twist.normalize();
+
+        // rotation * twist.conjugated()
+        swing._multiplyQuaternions(x, y, z, w, -twist.x, -twist.y, -twist.z, twist.w);
+    }
+
+    /**
+     * Compute rotation (twist) around input axis
+     * @param {Vector3} axis
+     * @returns {number} in radians
+     */
+    computeTwistAngle(axis) {
+        assert.defined(axis, "axis");
+
+        const swing = new Quaternion();
+        const twist = new Quaternion();
+
+        this.computeSwingAndTwist(axis, swing, twist);
+
+        // extract twist angle from quaternion, see {@link #toAxisAngle}
+        return Math.acos(twist.w) * 2;
+    }
+
+    /**
+     *
+     * @param {Vector3} axis
+     * @returns {number} angle in radians
+     */
+    toAxisAngle(axis) {
+        const rad = Math.acos(this.w) * 2.0;
+
+        const s = Math.sin(rad / 2.0);
+
+        if (s > EPSILON) {
+            axis.set(
+                this.x / s,
+                this.y / s,
+                this.z / s
+            );
+        } else {
+            // If s is zero, return any axis (no rotation - axis does not matter)
+            axis.set(1, 0, 0);
+        }
+        return rad;
+    }
+
+    normalize() {
+        let l = this.length();
+
+        if (l < EPSILON) {
+            // use identity
+            this.set(0, 0, 0, 1);
+        } else {
+            const m = 1 / l;
+            this.multiplyScalar(m);
+        }
+    }
+
+    /**
+     *
+     * @param {number} val
+     * @return {Quaternion}
+     */
+    multiplyScalar(val) {
+        return this.set(
+            this.x * val,
+            this.y * val,
+            this.z * val,
+            this.w * val
+        );
+    }
+
+    /**
+     * @see http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+     * @param {Quaternion} other
+     */
+    multiply(other) {
+        this.multiplyQuaternions(this, other);
+    }
+
+    /**
+     *
+     * @param {Quaternion} first
+     * @param {Quaternion} second
+     */
+    multiplyQuaternions(first, second) {
+        const aX = first.x;
+        const aY = first.y;
+        const aZ = first.z;
+        const aW = first.w;
+
+        const bX = second.x;
+        const bY = second.y;
+        const bZ = second.z;
+        const bW = second.w;
+
+        this._multiplyQuaternions(aX, aY, aZ, aW, bX, bY, bZ, bW)
+    }
+
+    /**
+     *
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @param {number} aw
+     * @param {number} bx
+     * @param {number} by
+     * @param {number} bz
+     * @param {number} bw
+     * @return {Quaternion}
+     */
+    _multiplyQuaternions(ax, ay, az, aw, bx, by, bz, bw) {
+
+        const x = ax * bw + aw * bx + ay * bz - az * by;
+        const y = ay * bw + aw * by + az * bx - ax * bz;
+        const z = az * bw + aw * bz + ax * by - ay * bx;
+        const w = aw * bw - ax * bx - ay * by - az * bz;
+
+        return this.set(x, y, z, w);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    length() {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        return Math.sqrt(x * x + y * y + z * z + w * w);
+    }
+
+    /**
+     *
+     * @param {Quaternion} other
+     * @param {number} max_delta
+     */
+    rotateTowards(other, max_delta) {
+        Quaternion.rotateTowards(this, this, other, max_delta);
+    }
+
+    /**
+     *
+     * @param {Vector3} direction
+     * @param {Vector3} [up]
+     * @param {Vector3} [forward]
+     */
+    alignToDirection(direction, up = Vector3.up, forward = Vector3.forward) {
+
+        const dot = up.dot(direction);
+
+
+        if (Math.abs(dot + 1) < 0.000001) {
+            // vector a and b point exactly in the opposite direction,
+            // so it is a 180 degrees turn around the up-axis
+            this.set(forward.x, forward.y, forward.z, Math.PI);
+        } else if (Math.abs(dot - 1) < 0.000001) {
+            // vector a and b point exactly in the same direction
+            // so we return the identity quaternion
+            this.set(0, 0, 0, 1);
+        }
+
+        const angle = Math.acos(dot);
+
+        axis.crossVectors(up, direction);
+        axis.normalize();
+
+        this.fromAxisAngle(axis, angle);
+    }
+
+    /**
+     *
+     * @param {Vector3} source
+     * @param {Vector3} target
+     */
+    lookAt(source, target) {
+        const forward = new Vector3();
+
+        forward.subVectors(target, source);
+
+        forward.normalize();
+
+        this.alignToDirection(forward);
+    }
+
+    /**
+     *
+     * @param {function():number} random
+     */
+    setRandom(random) {
+        this.set(random(), random(), random(), random());
+
+        this.normalize();
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {String} order a combination of capital letters X,Y,Z. Examples: XYZ, YXZ
+     * @returns {Quaternion}
+     */
+    __setFromEuler(x, y, z, order = 'XYZ') {
+
+        // http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+
+        if (order === 'XYZ') {
+
+            this.fromEulerAnglesXYZ(x, y, z);
+
+        } else if (order === 'YXZ') {
+
+            this.fromEulerAnglesYXZ(x, y, z);
+
+        } else if (order === 'ZXY') {
+
+            this.fromEulerAnglesZXY(x, y, z);
+
+        } else if (order === 'ZYX') {
+
+            this.fromEulerAnglesZYX(x, y, z);
+
+        } else if (order === 'YZX') {
+
+            this.fromEulerAnglesYZX(x, y, z);
+
+        } else if (order === 'XZY') {
+
+            this.fromEulerAnglesXZY(x, y, z);
+
+        }
+
+        return this;
+    }
+
+    /**
+     * @see https://localcoder.org/euler-angle-to-quaternion-then-quaternion-to-euler-angle
+     * @see https://discourse.mcneel.com/t/what-is-the-right-method-to-convert-quaternion-to-plane-using-rhinocommon/92411/21?page=2
+     * @param {Vector3} result
+     */
+    toEulerAnglesXYZ(result) {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        const w2 = w * w;
+        const x2 = x * x;
+        const y2 = y * y;
+        const z2 = z * z;
+
+        const r31 = 2 * (x * w - y * z);
+        const r32 = w2 - x2 - y2 + z2;
+
+        const psi = Math.atan2(r31, r32);
+
+        const r21 = 2 * (x * z + y * w);
+
+        const theta = Math.asin(r21);
+
+        const r11 = 2 * (z * w - x * y);
+        const r12 = w2 + x2 - y2 - z2;
+
+        const phi = Math.atan2(r11, r12);
+
+        result.set(psi, theta, phi);
+    }
+
+    /**
+     * Adapted from http://bediyap.com/programming/convert-quaternion-to-euler-rotations/
+     * @param {Vector3} result
+     */
+    toEulerAnglesYXZ(result) {
+
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+
+        const z2 = z * z;
+        const x2 = x * x;
+        const w2 = w * w;
+        const y2 = y * y;
+
+        const r11 = 2 * (x * z + w * y),
+            r12 = w2 - x2 - y2 + z2,
+            r21 = -2 * (y * z - w * x),
+            r31 = 2 * (x * y + w * z),
+            r32 = w2 - x2 + y2 - z2;
+
+        const psi = Math.atan2(r31, r32);
+        const theta = Math.asin(r21);
+        const phi = Math.atan2(r11, r12);
+
+        // result.set(psi, theta, phi);
+        result.set(theta, phi, psi);
+    }
+
+    /**
+     * Adapted from http://bediyap.com/programming/convert-quaternion-to-euler-rotations/
+     * @param {Vector3} result
+     */
+    toEulerAnglesZYX(result) {
+
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+
+        const xx = x * x;
+        const yy = y * y;
+        const zz = z * z;
+        const ww = w * w;
+
+        const r11 = 2 * (x * y + w * z),
+            r12 = ww + xx - yy - zz,
+            r21 = -2 * (x * z - w * y),
+            r31 = 2 * (y * z + w * x),
+            r32 = ww - xx - yy + zz;
+
+        const psi = Math.atan2(r31, r32);
+        const theta = Math.asin(r21);
+        const phi = Math.atan2(r11, r12);
+
+        result.set(psi, theta, phi);
+    }
+
+    /**
+     *
+     * @param {Matrix4} m
+     */
+    threeSetRotationMatrix(m) {
+        this.__setFromRotationMatrix(m.elements);
+    }
+
+    /**
+     *
+     * @param {Array.<Number>} elements
+     */
+    __setRotationMatrix(elements) {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        const x2 = x + x;
+        const y2 = y + y;
+        const z2 = z + z;
+
+        const xx = x * x2;
+        const xy = x * y2;
+        const xz = x * z2;
+
+        const yy = y * y2;
+        const yz = y * z2;
+        const zz = z * z2;
+
+        const wx = w * x2;
+        const wy = w * y2;
+        const wz = w * z2;
+
+        // set 3x3 rotation matrix
+        elements[0] = 1 - (yy + zz);
+        elements[4] = xy - wz;
+        elements[8] = xz + wy;
+
+        elements[1] = xy + wz;
+        elements[5] = 1 - (xx + zz);
+        elements[9] = yz - wx;
+
+        elements[2] = xz - wy;
+        elements[6] = yz + wx;
+        elements[10] = 1 - (xx + yy);
+
+        // last column
+        elements[3] = 0;
+        elements[7] = 0;
+        elements[11] = 0;
+
+        // bottom row
+        elements[12] = 0;
+        elements[13] = 0;
+        elements[14] = 0;
+        elements[15] = 1;
+    }
+
+    /**
+     * 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
+     */
+    fromEulerAngles(x, y, z) {
+        return this.fromEulerAnglesXYZ(x, y, 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;
+
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(half_x);
+        const s2 = sin(half_y);
+        const s3 = sin(half_z);
+
+        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;
+
+        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
+     */
+    fromEulerAnglesYXZ(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
+
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = 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
+     */
+    fromEulerAnglesZXY(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
+
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = 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
+     */
+    fromEulerAnglesZYX(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
+
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = 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
+     */
+    fromEulerAnglesYZX(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
+
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = 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 sin = Math.sin;
+        const cos = Math.cos;
+
+        const s1 = sin(scaled_x);
+        const s2 = sin(scaled_y);
+        const s3 = sin(scaled_z);
+
+        const c1 = cos(scaled_x);
+        const c2 = cos(scaled_y);
+        const c3 = 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);
+    }
+
+    /**
+     * Based on blog post: http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
+     * @param {Vector3} from
+     * @param {Vector3} to
+     */
+    fromNonUnitVectors(from, to) {
+        //quat quat::fromtwovectors(vec3 u, vec3 v)
+        // {
+        //     vec3 w = cross(u, v);
+        //     quat q = quat(dot(u, v), w.x, w.y, w.z);
+        //     q.w += length(q);
+        //     return normalize(q);
+        // }
+
+        const ax = from.x;
+        const ay = from.y;
+        const az = from.z;
+
+        const bx = to.x;
+        const by = to.y;
+        const bz = to.z;
+
+        //compute cross product
+        const crossX = ay * bz - az * by;
+        const crossY = az * bx - ax * bz;
+        const crossZ = ax * by - ay * bx;
+
+        const uv_dot = v3_dot(ax, ay, az, bx, by, bz);
+
+
+        const qX = crossX;
+        const qY = crossY;
+        const qZ = crossZ;
+        const qW = uv_dot;
+
+        const p0 = qX * qX + qY * qY + qZ * qZ;
+
+        const l0 = Math.sqrt(p0 + qW * qW);
+
+        const qW_1 = qW + l0;
+
+        //normalize result
+        const l1 = Math.sqrt(p0 + qW_1 * qW_1);
+
+        const x = qX / l1;
+        const y = qY / l1;
+        const z = qZ / l1;
+        const w = qW / l1;
+
+        this.set(x, y, z, w);
+    }
+
+    /**
+     * Based on blog post: http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
+     * @param {Vector3} from
+     * @param {Vector3} to
+     */
+    fromUnitVectors2(from, to) {
+        assert.ok(from.isNormalized(), `from vector is not normalized, length = ${from.length()}`);
+        assert.ok(to.isNormalized(), `to vector is not normalized, length = ${to.length()}`);
+
+        //quat quat::fromtwovectors(vec3 u, vec3 v)
+        // {
+        //     float m = sqrt(2.f + 2.f * dot(u, v));
+        //     vec3 w = (1.f / m) * cross(u, v);
+        //     return quat(0.5f * m, w.x, w.y, w.z);
+        // }
+
+        const ax = from.x;
+        const ay = from.y;
+        const az = from.z;
+
+        const bx = to.x;
+        const by = to.y;
+        const bz = to.z;
+
+        const uv_dot = v3_dot(ax, ay, az, bx, by, bz);
+
+        if (uv_dot === -1) {
+            //to vector is opposite, produce a reversal quaternion
+
+            tempvec3.crossVectors(Vector3.left, from);
+
+            if (tempvec3.lengthSqr() < 0.00001) {
+                tempvec3.crossVectors(Vector3.up, from);
+            }
+
+            tempvec3.normalize();
+
+            this.set(
+                tempvec3.x,
+                tempvec3.y,
+                tempvec3.z,
+                0
+            );
+
+            return;
+        }
+
+        const m = Math.sqrt(2 + 2 * uv_dot);
+
+        const inv_m = 1 / m;
+
+        //compute cross product
+        const crossX = ay * bz - az * by;
+        const crossY = az * bx - ax * bz;
+        const crossZ = ax * by - ay * bx;
+
+        //compute W vector
+        const wX = inv_m * crossX;
+        const wY = inv_m * crossY;
+        const wZ = inv_m * crossZ;
+
+
+        this.set(
+            wX,
+            wY,
+            wZ,
+            0.5 * m
+        );
+    }
+
+    /**
+     * Input vectors must be normalized
+     * @param {Vector3} from
+     * @param {Vector3} to
+     */
+    fromUnitVectors(from, to) {
+        assert.ok(from.isNormalized(), `from vector is not normalized, length = ${from.length()}`);
+        assert.ok(to.isNormalized(), `to vector is not normalized, length = ${to.length()}`);
+
+        const dot = from.dot(to);
+
+        let x, y, z, w;
+
+        if (dot < -0.9999999) {
+            const tempvec3 = new Vector3();
+
+            tempvec3.crossVectors(Vector3.left, from);
+
+            if (tempvec3.lengthSqr() < 0.00001) {
+                tempvec3.crossVectors(Vector3.up, from);
+            }
+
+            tempvec3.normalize();
+
+            this.fromAxisAngle(tempvec3, Math.PI);
+        } else if (dot > 0.9999999) {
+            x = 0;
+            y = 0;
+            z = 0;
+            w = 1;
+
+            this.set(x, y, z, w);
+        } else {
+            //cross product from x to
+
+            x = from.y * to.z - from.z * to.y;
+            y = from.z * to.x - from.x * to.z;
+            z = from.x * to.y - from.y * to.x;
+            w = 1 + dot;
+
+            this.set(x, y, z, w);
+            this.normalize();
+        }
+    }
+
+    /**
+     *
+     * @param {Matrix4} m
+     */
+    setFromRotationMatrix(m) {
+        const e = m.elements;
+
+        this.__setFromRotationMatrix(
+            e[0], e[4], e[8],
+            e[1], e[5], e[9],
+            e[2], e[6], e[10]
+        );
+
+    }
+
+    /**
+     * This algorithm comes from  "Quaternion Calculus and Fast Animation",
+     * Ken Shoemake, 1987 SIGGRAPH course notes
+     * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/Quaternion.h#L813
+     * @param {number} m11
+     * @param {number} m12
+     * @param {number} m13
+     * @param {number} m21
+     * @param {number} m22
+     * @param {number} m23
+     * @param {number} m31
+     * @param {number} m32
+     * @param {number} m33
+     * @returns {Quaternion}
+     */
+    __setFromRotationMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33) {
+        const trace = m11 + m22 + m33;
+
+        let x, y, z, w, s;
+
+        if (trace > 0) {
+
+            s = Math.sqrt(trace + 1.0);
+
+            w = 0.5 * s;
+
+            s = 0.5 / s;
+
+            x = (m32 - m23) * s;
+            y = (m13 - m31) * s;
+            z = (m21 - m12) * s;
+
+        } else if (m11 > m22 && m11 > m33) {
+
+            s = Math.sqrt(1.0 + m11 - m22 - m33);
+
+            x = 0.5 * s;
+
+            s = 0.5 / s;
+
+            w = (m32 - m23) * s;
+            y = (m12 + m21) * s;
+            z = (m13 + m31) * s;
+
+        } else if (m22 > m33) {
+
+            s = Math.sqrt(1.0 + m22 - m11 - m33);
+
+            y = 0.5 * s;
+
+            s = 0.5 / s;
+
+            w = (m13 - m31) * s;
+            x = (m12 + m21) * s;
+            z = (m23 + m32) * s;
+
+        } else {
+
+            s = Math.sqrt(1.0 + m33 - m11 - m22);
+
+            z = 0.5 * s;
+
+            s = 0.5 / s;
+
+            w = (m21 - m12) * s;
+            x = (m13 + m31) * s;
+            y = (m23 + m32) * s;
+
+        }
+
+        return this.set(x, y, z, w);
+    }
+
+    /**
+     * Linear interpolation
+     * @param {Quaternion} other
+     * @param {number} t fractional value between 0 and 1
+     */
+    lerp(other, t) {
+
+        this.lerpQuaternions(this, other, t);
+
+    }
+
+    /**
+     *
+     * @param {Quaternion} first
+     * @param {Quaternion} second
+     * @param {number} t
+     */
+    lerpQuaternions(first, second, t) {
+
+        assert.isNumber(t, 't');
+
+        assert.greaterThanOrEqual(t, 0, 't >= 0');
+        assert.lessThanOrEqual(t, 1, 't <= 1');
+
+        const x = lerp(first.x, second.x, t);
+        const y = lerp(first.y, second.y, t);
+        const z = lerp(first.z, second.z, t);
+        const w = lerp(first.w, second.w, t);
+
+
+        this.set(x, y, z, w);
+    }
+
+
+    /**
+     * @see https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
+     * @param {Quaternion} other
+     * @param {number} t
+     */
+    slerp(other, t) {
+        assert.isNumber(t, 't');
+
+        const ax = this.x,
+            ay = this.y,
+            az = this.z,
+            aw = this.w;
+
+        let bx = other.x,
+            by = other.y,
+            bz = other.z,
+            bw = other.w;
+
+        let omega, cosom, sinom, scale0, scale1;
+
+        // calc cosine
+        cosom = ax * bx + ay * by + az * bz + aw * bw;
+
+        // adjust signs (if necessary)
+        if (cosom < 0.0) {
+            cosom = -cosom;
+            bx = -bx;
+            by = -by;
+            bz = -bz;
+            bw = -bw;
+        }
+        // calculate coefficients
+        if ((1.0 - cosom) > EPSILON) {
+            // standard case (slerp)
+            omega = Math.acos(cosom);
+            sinom = Math.sin(omega);
+            scale0 = Math.sin((1.0 - t) * omega) / sinom;
+            scale1 = Math.sin(t * omega) / sinom;
+        } else {
+            // "from" and "to" quaternions are very close
+            //  ... so we can do a linear interpolation
+            scale0 = 1.0 - t;
+            scale1 = t;
+        }
+
+        // calculate final values
+        const _x = scale0 * ax + scale1 * bx;
+        const _y = scale0 * ay + scale1 * by;
+        const _z = scale0 * az + scale1 * bz;
+        const _w = scale0 * aw + scale1 * bw;
+
+        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
+     */
+    process(handler) {
+        handler(this.x, this.y, this.z, this.w);
+
+        this.onChanged.add(handler);
+    }
+
+    /**
+     *
+     * @param {Quaternion} other
+     * @returns {Quaternion}
+     */
+    copy(other) {
+        return this.set(other.x, other.y, other.z, other.w);
+    }
+
+    /**
+     *
+     * @returns {Quaternion}
+     */
+    clone() {
+        const result = new Quaternion();
+
+        result.copy(this);
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     * @returns {Quaternion}
+     */
+    set(x, y, z, w) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+        assert.isNumber(z, 'z');
+        assert.isNumber(w, 'w');
+
+        assert.notNaN(x, 'x');
+        assert.notNaN(y, 'y');
+        assert.notNaN(z, 'z');
+        assert.notNaN(w, 'w');
+
+        const _x = this.x;
+        const _y = this.y;
+        const _z = this.z;
+        const _w = this.w;
+
+        if (_x !== x || _y !== y || _z !== z || _w !== w) {
+
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.w = w;
+
+            if (this.onChanged.hasHandlers()) {
+                this.onChanged.send8(x, y, z, w, _x, _y, _z, _w);
+            }
+        }
+
+        return this;
+    }
+
+    /**
+     *
+     * @returns {Quaternion}
+     */
+    conjugate() {
+        return this.set(-this.x, -this.y, -this.z, this.w);
+    }
+
+    toJSON() {
+        return {
+            x: this.x,
+            y: this.y,
+            z: this.z,
+            w: this.w
+        };
+    }
+
+    fromJSON(obj) {
+        this.set(obj.x, obj.y, obj.z, obj.w);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.x);
+        buffer.writeFloat64(this.y);
+        buffer.writeFloat64(this.z);
+        buffer.writeFloat64(this.w);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const x = buffer.readFloat64();
+        const y = buffer.readFloat64();
+        const z = buffer.readFloat64();
+        const w = buffer.readFloat64();
+
+        this.set(x, y, z, w);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBufferFloat32(buffer) {
+        buffer.writeFloat32(this.x);
+        buffer.writeFloat32(this.y);
+        buffer.writeFloat32(this.z);
+        buffer.writeFloat32(this.w);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBufferFloat32(buffer) {
+        const x = buffer.readFloat32();
+        const y = buffer.readFloat32();
+        const z = buffer.readFloat32();
+        const w = buffer.readFloat32();
+
+        this.set(x, y, z, w);
+    }
+
+    /**
+     * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+     * @param {number} value
+     */
+    decodeFromUint32(value) {
+        //read components
+        const max = value & 0x3;
+
+        const iv0 = (value >> 2) & 0x3FF;
+        const iv1 = (value >> 12) & 0x3FF;
+        const iv2 = (value >> 22) & 0x3FF;
+
+        //scale components back to quaternion range
+        const v0 = (iv0 / 511 - 1) * K_CONST;
+        const v1 = (iv1 / 511 - 1) * K_CONST;
+        const v2 = (iv2 / 511 - 1) * K_CONST;
+
+        //restore dropped component using quaternion identity: x^2 + y^2 + z^2 + w^2 = 1
+        const dropped_2 = 1 - v0 * v0 - v1 * v1 - v2 * v2;
+        const dropped = Math.sqrt(dropped_2);
+
+        if (max === 0) {
+            this.set(dropped, v0, v1, v2);
+        } else if (max === 1) {
+            this.set(v0, dropped, v1, v2);
+        } else if (max === 2) {
+            this.set(v0, v1, dropped, v2);
+        } else {
+            this.set(v0, v1, v2, dropped);
+        }
+    }
+
+    /**
+     * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+     * @returns {number}
+     */
+    encodeToUint32() {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+
+        const absX = Math.abs(x);
+        const absY = Math.abs(y);
+        const absZ = Math.abs(z);
+        const absW = Math.abs(w);
+
+        let max = 0;
+
+        //pick max component
+        if (absY > absX) {
+            if (absY > absZ) {
+                if (absY > absW) {
+                    //absY is max
+                    max = 1;
+                } else {
+                    //absW is max
+                    max = 3;
+                }
+            } else if (absZ > absW) {
+                //absZ is max
+                max = 2;
+            } else {
+                //absW is max
+                max = 3;
+            }
+        } else if (absX > absZ) {
+            if (absX > absW) {
+                max = 0;
+            } else {
+                max = 3;
+            }
+        } else if (absZ > absW) {
+            max = 2;
+        } else {
+            max = 3;
+        }
+
+        let v0, v1, v2, dropped;
+
+        //max will be dropped
+        if (max === 0) {
+            //dropping x
+            v0 = y;
+            v1 = z;
+            v2 = w;
+
+            dropped = x;
+        } else if (max === 1) {
+            //dropping y
+            v0 = x;
+            v1 = z;
+            v2 = w;
+
+            dropped = y;
+        } else if (max === 2) {
+            //dropping z
+            v0 = x;
+            v1 = y;
+            v2 = w;
+
+            dropped = z;
+        } else {
+            //dropping w
+            v0 = x;
+            v1 = y;
+            v2 = z;
+
+            dropped = w;
+        }
+
+        if (dropped < 0) {
+            //reconstructing dropped value is only possible if it is positive, so we invert the quaternion to make dropped value positive
+            v0 = -v0;
+            v1 = -v1;
+            v2 = -v2;
+        }
+
+        const l = Math.sqrt(x * x + y * y + z * z + w * w);
+        const m = 1 / (l * K_CONST);
+
+        //re-normalize the remaining components to 10 bit UINT value
+        const oV0 = Math.round((v0 * m + 1) * 511);
+        const oV1 = Math.round((v1 * m + 1) * 511);
+        const oV2 = Math.round((v2 * m + 1) * 511);
+
+        assert.ok(oV0 <= 1023 && oV0 >= 0, `expected 0 <= ov0 <= 1023, instead was '${oV0}'`);
+        assert.ok(oV1 <= 1023 && oV1 >= 0, `expected 0 <= ov1 <= 1023, instead was '${oV1}'`);
+        assert.ok(oV2 <= 1023 && oV2 >= 0, `expected 0 <= ov2 <= 1023, instead was '${oV2}'`);
+
+
+        const result = (max & 0x3)
+            | ((oV0 & 0x3FF) << 2)
+            | ((oV1 & 0x3FF) << 12)
+            | ((oV2 & 0x3FF) << 22)
+        ;
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    readFromArray(array, offset=0) {
+        this.set(
+            array[offset],
+            array[offset + 1],
+            array[offset + 2],
+            array[offset + 3]
+        );
+    }
+
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    writeToArray(array, offset=0) {
+        array[offset] = this.x;
+        array[offset + 1] = this.y;
+        array[offset + 2] = this.z;
+        array[offset + 3] = this.w;
+    }
+
+    asArray() {
+        return [this.x, this.y, this.z, this.w];
+    }
+
+    /**
+     *
+     * @param {Quaternion} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.x === other.x
+            && this.y === other.y
+            && this.z === other.z
+            && this.w === other.w
+            ;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        // fast and dumb hash, just spread bits a bit and XOR them
+        return computeHashFloat(this.x)
+            ^ (computeHashFloat(this.y) >> 2)
+            ^ (computeHashFloat(this.z) >> 1)
+            ^ (computeHashFloat(this.w) << 2);
+    }
+
+    /**
+     *
+     * @param {Quaternion} other
+     * @param {number} [tolerance]
+     * @return {boolean}
+     */
+    roughlyEquals(other, tolerance) {
+        return this._roughlyEquals(other.x, other.y, other.z, other.w, tolerance);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     * @param {number} [tolerance]
+     * @return {boolean}
+     * @private
+     */
+    _roughlyEquals(x, y, z, w, tolerance = EPSILON) {
+        return epsilonEquals(this.x, x, tolerance)
+            && epsilonEquals(this.y, y, tolerance)
+            && epsilonEquals(this.z, z, tolerance)
+            && epsilonEquals(this.w, w, tolerance);
+    }
+
+    * [Symbol.iterator]() {
+
+        yield this.x;
+        yield this.y;
+        yield this.z;
+        yield this.w;
+
+    }
+
+    /**
+     * Based on http://planning.cs.uiuc.edu/node198.html
+     * @param {function():number} [random]
+     * @return {Quaternion}
+     */
+    random(random = Math.random) {
+        const u1 = random();
+
+        const sqrt1u1 = Math.sqrt(1 - u1);
+        const sqrtu1 = Math.sqrt(u1);
+
+        const u2 = 2 * Math.PI * random();
+
+        const u3 = 2 * Math.PI * random();
+
+        return this.set(
+            sqrt1u1 * Math.cos(u2),
+            sqrtu1 * Math.sin(u3),
+            sqrtu1 * Math.cos(u3),
+            sqrt1u1 * Math.sin(u2),
+        );
+    }
+
+    /**
+     *
+     * @param {function} random random number generator function
+     * @returns {Quaternion}
+     */
+    static random(random = Math.random) {
+        const result = new Quaternion();
+
+        result.random(random);
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Quaternion}
+     */
+    static fromEulerAngles(x, y, z) {
+        const r = new Quaternion();
+
+        r.fromEulerAnglesXYZ(x, y, z);
+
+        return r;
+    }
+
+    /**
+     * Behaves similarly to Unity's Quaternion `RotateToward` method
+     * @param {Quaternion} result
+     * @param {Quaternion} from
+     * @param {Quaternion} to
+     * @param {number} max_delta
+     */
+    static rotateTowards(result, from, to, max_delta) {
+        assert.isNumber(max_delta, 'max_delta');
+
+        const angle = from.angleTo(to);
+
+        if (angle === 0) {
+            result.copy(to);
+        } else {
+            // clamp to 1, to make sure we don't overshoot
+            const t = min2(1, max_delta / angle);
+
+            from.slerp(to, t);
+        }
+
+    }
+}
+
+/**
+ * @readonly
+ * @type {Quaternion}
+ */
+Quaternion.identity = Object.freeze(new Quaternion(0, 0, 0, 1));
+
+
+/**
+ *
+ * @type {Vector3}
+ */
+const axis = new Vector3();
+
+
+const tempvec3 = new Vector3();
+
+/**
+ * Used in UINT32 packing
+ * @type {number}
+ */
+const K_CONST = 0.70710678118; // 1/sqrt(2)
+
+export default Quaternion;