@woosh/meep-engine 2.37.17 → 2.37.20

package/core/geom/Quaternion.js

@@ -7,11 +7,12 @@ 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";
+import { min2 } from "../math/min2.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 const matrix = new ThreeMatrix4();
 
@@ -46,39 +47,46 @@ class Quaternion {
      * @param {Number} [w=1]
      * @constructor
      */
-    constructor(x, y, z, w) {
-        this.x = (typeof x === "number") ? x : 0;
-        this.y = (typeof x === "number") ? y : 0;
-        this.z = (typeof z === "number") ? z : 0;
-        this.w = (typeof w === "number") ? w : 1;
+    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();
     }
 
-    /**
-     *
-     * @param {Vector3} forwardVector
-     * @return {Quaternion}
-     */
-    lookRotation_2(forwardVector) {
-
-
-        const dot = Vector3.forward.dot(forwardVector);
-        if (Math.abs(dot - (-1.0)) < 0.000001) {
-            return this.set(Vector3.up.x, Vector3.up.y, Vector3.up.z, 3.1415926535897932);
-        }
-        if (Math.abs(dot - (1.0)) < 0.000001) {
-            return this.set(0, 0, 0, 1);
-        }
+    get 0() {
+        return this.x;
+    }
 
-        const rotAngle = Math.acos(dot);
-        rotAxis.copy(Vector3.forward);
-        rotAxis.cross(forwardVector);
-        rotAxis.normalize();
+    get 1() {
+        return this.y;
+    }
 
-        quat3_createFromAxisAngle(rotAxis, rotAngle, this);
+    get 2() {
+        return this.z;
+    }
 
-        return this;
+    get 3() {
+        return this.w;
     }
 
     /**
@@ -172,30 +180,6 @@ class Quaternion {
         return euler.setFromRotationMatrix(matrix);
     }
 
-    /**
-     *
-     * @param {Vector3} direction
-     * @param {Vector3} reference Reference direction, for example if you want to align Up direction or Forward, supply those here
-     * @param {number} limit
-     */
-    lookRotation_3(direction, reference, limit) {
-        const q = new Quaternion();
-
-        const f = new Vector3();
-
-        f.copy(reference);
-
-        f.applyQuaternion(this);
-
-        f.normalize();
-
-        //
-        q.fromUnitVectors2(f, direction);
-
-        console.log(f.toJSON(), q.toJSON(), direction.toJSON(), reference.toJSON());
-
-        this.multiply(q);
-    }
 
     /**
      *
@@ -318,11 +302,10 @@ class Quaternion {
     }
 
     /**
-     *
+     * @see https://stackoverflow.com/questions/3684269/component-of-a-quaternion-rotation-around-an-axis
      * @param {Vector3} axis
      * @param {Quaternion} swing
      * @param {Quaternion} twist
-     * @returns {number}
      */
     computeSwingAndTwist(axis, swing, twist) {
         const x = this.x;
@@ -330,17 +313,48 @@ class Quaternion {
         const z = this.z;
         const w = this.w;
 
-        const p = new Vector3();
+        // 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);
 
-        p._projectVectors(x, y, z, axis.x, axis.y, 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.set(p.x, p.y, p.z, 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
@@ -367,7 +381,8 @@ class Quaternion {
     normalize() {
         let l = this.length();
 
-        if (l === 0) {
+        if (l < EPSILON) {
+            // use identity
             this.set(0, 0, 0, 1);
         } else {
             const m = 1 / l;
@@ -473,10 +488,9 @@ class Quaternion {
     lookAt(source, target) {
         const forward = new Vector3();
 
-        forward
-            .copy(target)
-            .sub(source)
-            .normalize();
+        forward.subVectors(target, source);
+
+        forward.normalize();
 
         this.alignToDirection(forward);
     }
@@ -503,92 +517,41 @@ 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;
     }
 
     /**
-     *
+     * @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;
@@ -599,9 +562,19 @@ class Quaternion {
         const y2 = y * y;
         const z2 = z * z;
 
-        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 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);
     }
@@ -727,64 +700,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 _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 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);
     }
@@ -798,7 +782,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 +795,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 +804,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);
 
-        //normalize angles
-        yaw = normalizeAngle(yaw);
-        pitch = normalizeAngle(pitch);
-        roll = normalizeAngle(roll);
+        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);
+
+        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);
     }
 
     /**
@@ -1152,6 +1181,7 @@ class Quaternion {
         this.set(x, y, z, w);
     }
 
+
     /**
      * @see https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
      * @param {Quaternion} other
@@ -1204,6 +1234,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
@@ -1496,6 +1537,18 @@ class Quaternion {
             ;
     }
 
+    /**
+     *
+     * @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
@@ -1567,6 +1620,28 @@ class Quaternion {
 
         return result;
     }
+
+
+    /**
+     * 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) {
+        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);
+        }
+
+    }
 }
 
 /**
@@ -1585,6 +1660,10 @@ 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;