@lakuna/umath 1.5.0 → 3.0.0

package/dist/linalg/Quaternion.js

@@ -1,16 +1,17 @@
+import radiansToDegrees from "../algorithms/radiansToDegrees.js";
+import createAxisAngleLike from "../utility/createAxisAngleLike.js";
+import epsilon from "../utility/epsilon.js";
 import { createMatrix3Like, fromValues as matrix3FromValues } from "./Matrix3.js";
 import Vector3, { createVector3Like, cross as vector3Cross, dot as vector3Dot, fromValues as vector3FromValues, getMagnitude as vector3GetMagnitude, normalize as vector3Normalize } from "./Vector3.js";
 import { add as vector4Add, copy as vector4Copy, dot as vector4Dot, exactEquals as vector4ExactEquals, fromValues as vector4FromValues, getMagnitude as vector4GetMagnitude, getSquaredMagnitude as vector4GetSquaredMagnitude, lerp as vector4Lerp, normalize as vector4Normalize, scale as vector4Scale } from "./Vector4.js";
-import epsilon from "../utility/epsilon.js";
-import radiansToDegrees from "../algorithms/radiansToDegrees.js";
 /**
  * Create a quaternion-like object.
  * @returns A quaternion-like object.
  * @public
  */
-export const createQuaternionLike = () => {
-    return new Float32Array(4);
-};
+export const createQuaternionLike = () => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+new Float32Array(4);
 /**
  * Create a quaternion with the given values.
  * @param x - The first component.
@@ -132,24 +133,34 @@ export const fromMatrix3 = (matrix, out) => {
     if (m4 > m0) {
         i = 1;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     if (m8 > matrix[(i * 3 + i)]) {
         i = 2;
     }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     const j = ((i + 1) % 3);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     const k = ((i + 2) % 3);
-    let fRoot = Math.sqrt(matrix[(i * 3 + i)] -
+    let fRoot = Math.sqrt(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    matrix[(i * 3 + i)] -
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         matrix[(j * 3 + j)] -
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         matrix[(k * 3 + k)] +
         1);
     out[i] = fRoot / 2;
     fRoot = 0.5 / fRoot;
     out[3] =
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         (matrix[(j * 3 + k)] - matrix[(k * 3 + j)]) *
             fRoot;
     out[j] =
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         (matrix[(j * 3 + i)] + matrix[(i * 3 + j)]) *
             fRoot;
     out[k] =
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         (matrix[(k * 3 + i)] + matrix[(i * 3 + k)]) *
             fRoot;
     return out;
@@ -514,7 +525,7 @@ export const exp = (quaternion, out) => {
     const x = quaternion[0];
     const y = quaternion[1];
     const z = quaternion[2];
-    const r = Math.sqrt(x * x + y * y + z * z); // `Math.hypot` is slower.
+    const r = Math.hypot(x, y, z);
     const et = Math.exp(quaternion[3]);
     const s = r > 0 ? (et * Math.sin(r)) / r : 0;
     return fromValues(x * s, y * s, z * s, et * Math.cos(r), out);
@@ -532,7 +543,7 @@ export const ln = (quaternion, out) => {
     const z = quaternion[2];
     const w = quaternion[3];
     const xyz2 = x * x + y * y + z * z;
-    const r = Math.sqrt(xyz2); // `Math.hypot` is slower.
+    const r = Math.sqrt(xyz2);
     const t = r > 0 ? Math.atan2(r, w) / r : 0;
     return fromValues(x * t, y * t, z * t, Math.log(xyz2 + w * w) / 2, out);
 };
@@ -572,9 +583,9 @@ export const slerp = (a, b, t, out) => {
         bz = -bz;
         bw = -bw;
     }
-    // eslint-disable-next-line init-declarations
+    // eslint-disable-next-line @typescript-eslint/init-declarations
     let scale0;
-    // eslint-disable-next-line init-declarations
+    // eslint-disable-next-line @typescript-eslint/init-declarations
     let scale1;
     if (1 - cosom > epsilon) {
         const omega = Math.acos(cosom);
@@ -682,27 +693,79 @@ export const fromRotationTo = (a, b, out) => {
  * @public
  */
 export default class Quaternion extends Float32Array {
+    /** The first component of this quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    0;
+    /** The second component of this quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    1;
+    /** The third component of this quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    2;
+    /** The fourth component of this quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    3;
+    /** The axis and angle that represent this quaternion. */
+    get axisAngle() {
+        return getAxisAngle(this, createAxisAngleLike());
+    }
+    set axisAngle(value) {
+        setAxisAngle(value, this);
+    }
+    /** Get the magnitude (length) of this quaternion. */
+    get magnitude() {
+        return getMagnitude(this);
+    }
+    /** Get the squared magnitude (length) of this quaternion. */
+    get squaredMagnitude() {
+        return getSquaredMagnitude(this);
+    }
     /**
-     * Create a quaternion from a three-by-three rotation matrix.
-     * @param matrix - The matrix.
-     * @param out - The quaternion to store the result in.
+     * Create an identity quaternion.
+     * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
+     */
+    constructor() {
+        super(4);
+        this[3] = 1;
+    }
+    /**
+     * Create a quaternion with values corresponding to the given orthonormal set of vectors.
+     * @param view - The vector representing the viewing direction.
+     * @param right - The vector representing the local "right" direction.
+     * @param up - The vector representing the local "up" direction.
      * @returns The quaternion.
-     * @see {@link https://en.wikipedia.org/wiki/Rotation_matrix | Rotation matrix}
      */
-    static fromMatrix3(matrix, out = new Quaternion()) {
-        return fromMatrix3(matrix, out);
+    static fromAxes(view, right, up) {
+        return fromAxes(view, right, up, new Quaternion());
     }
     /**
      * Create a quaternion from equivalent z-y'-x" (intrinsic) Tait-Bryan angles.
      * @param z - The z (roll) angle.
      * @param y - The y (pitch) angle.
      * @param x - The x (yaw) angle.
-     * @param out - The quaternion to store the result in.
      * @returns The quaternion.
      * @see {@link https://en.wikipedia.org/wiki/Euler_angles | Euler angles}
      */
-    static fromEuler(z, y, x, out = new Quaternion()) {
-        return fromEuler(z, y, x, out);
+    static fromEuler(z, y, x) {
+        return fromEuler(z, y, x, new Quaternion());
+    }
+    /**
+     * Create a quaternion from a three-by-three rotation matrix.
+     * @param matrix - The matrix.
+     * @returns The quaternion.
+     * @see {@link https://en.wikipedia.org/wiki/Rotation_matrix | Rotation matrix}
+     */
+    static fromMatrix3(matrix) {
+        return fromMatrix3(matrix, new Quaternion());
+    }
+    /**
+     * Create a unit quaternion that represents the shortest rotation from one unit vector to another.
+     * @param a - The first unit vector.
+     * @param b - The second unit vector.
+     * @returns The unit quaternion.
+     */
+    static fromRotationTo(a, b) {
+        return fromRotationTo(a, b, new Quaternion());
     }
     /**
      * Create a quaternion with the given values.
@@ -710,71 +773,78 @@ export default class Quaternion extends Float32Array {
      * @param y - The second component.
      * @param z - The third component.
      * @param w - The fourth component.
-     * @param out - The quaternion to store the result in.
      * @returns A new quaternion.
      */
-    static fromValues(x, y, z, w, out = new Quaternion()) {
-        return fromValues(x, y, z, w, out);
+    static fromValues(x, y, z, w) {
+        return fromValues(x, y, z, w, new Quaternion());
     }
     /**
-     * Create a quaternion with values corresponding to the given orthonormal set of vectors.
-     * @param view - The vector representing the viewing direction.
-     * @param right - The vector representing the local "right" direction.
-     * @param up - The vector representing the local "up" direction.
-     * @param out - The quaternion to store the result in.
+     * Add two quaternions of the same size.
+     * @param quaternion - The other quaternion.
+     * @returns The sum of the quaternions.
+     */
+    add(quaternion) {
+        return add(this, quaternion, new Quaternion());
+    }
+    /**
+     * Calculate the fourth component of this unit quaternion from the first three, ignoring the existing fourth component.
      * @returns The quaternion.
      */
-    static fromAxes(view, right, up, out = new Quaternion()) {
-        return fromAxes(view, right, up, out);
+    calculateW() {
+        return calculateW(this, new Quaternion());
     }
     /**
-     * Create a unit quaternion that represents the shortest rotation from one unit vector to another.
-     * @param a - The first unit vector.
-     * @param b - The second unit vector.
-     * @param out - The quaternion to store the result in.
-     * @returns The unit quaternion.
+     * Copy the values from this quaternion to another one.
+     * @returns The copy.
      */
-    static fromRotationTo(a, b, out = new Quaternion()) {
-        return fromRotationTo(a, b, out);
+    clone() {
+        return copy(this, new Quaternion());
     }
     /**
-     * Create an identity quaternion.
-     * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
+     * Calculate the conjugate of this quaternion. If the quaternion is normalized, this is the same as the inverse but faster to calculate.
+     * @returns The conjugate.
      */
-    constructor() {
-        super(4);
-        this[3] = 1;
+    conjugate() {
+        return conjugate(this, new Quaternion());
     }
-    /** The first component of this quaternion. */
-    0;
-    /** The second component of this quaternion. */
-    1;
-    /** The third component of this quaternion. */
-    2;
-    /** The fourth component of this quaternion. */
-    3;
     /**
-     * Set this quaternion to the identity.
+     * Copy the values of another quaternion into this one.
+     * @param quaternion - The quaternion to copy.
      * @returns This quaternion.
      */
-    identity() {
-        return identity(this);
+    copy(quaternion) {
+        return copy(quaternion, this);
     }
     /**
-     * Get the axis and angle that represent this quaternion.
-     * @param out - The axis and angle to store the result in.
-     * @returns The axis and angle.
+     * Calculate the dot product of this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @returns The dot product.
      */
-    getAxisAngle(out = {}) {
-        return getAxisAngle(this, out);
+    dot(quaternion) {
+        return dot(this, quaternion);
     }
     /**
-     * Set the axis and angle that represent this quaternion.
-     * @param axisAngle - The axis and angle.
-     * @returns This quaternion.
+     * Determine whether or not this quaternion is roughly equivalent to another.
+     * @param quaternion - The other quaternion.
+     * @returns Whether or not the quaternions are equivalent.
      */
-    setAxisAngle(axisAngle) {
-        return setAxisAngle(axisAngle, this);
+    equals(quaternion) {
+        return equals(this, quaternion);
+    }
+    /**
+     * Determine whether or not this quaternion is exactly equivalent to another.
+     * @param quaternion - The other quaternion.
+     * @returns Whether or not the quaternions are equivalent.
+     */
+    exactEquals(quaternion) {
+        return exactEquals(this, quaternion);
+    }
+    /**
+     * Calculate the exponential of this unit quaternion.
+     * @returns The exponential.
+     */
+    exp() {
+        return exp(this, new Quaternion());
     }
     /**
      * Get the angular distance between this unit quaternion and another.
@@ -785,84 +855,57 @@ export default class Quaternion extends Float32Array {
         return getAngle(this, quaternion);
     }
     /**
-     * Multiply this and another quaternion.
-     * @param quaternion - The other quaternion.
-     * @param out - The quaternion to store the result in.
-     * @returns The product.
-     */
-    multiply(quaternion, out = new Quaternion()) {
-        return multiply(this, quaternion, out);
-    }
-    /**
-     * Rotate this quaternion by the given angle around the X-axis.
-     * @param r - The angle in radians.
-     * @param out - The quaternion to store the result in.
-     * @returns The rotated quaternion.
+     * Set this quaternion to the identity.
+     * @returns This quaternion.
      */
-    rotateX(r, out = new Quaternion()) {
-        return rotateX(this, r, out);
+    identity() {
+        return identity(this);
     }
     /**
-     * Rotate this quaternion by the given angle around the Y-axis.
-     * @param r - The angle in radians.
-     * @param out - The quaternion to store the result in.
-     * @returns The rotated quaternion.
+     * Calculate the inverse of this quaternion. If the quaternion is normalized, the conjugate is the same but faster to calculate.
+     * @returns The inverse.
      */
-    rotateY(r, out = new Quaternion()) {
-        return rotateY(this, r, out);
+    invert() {
+        return invert(this, new Quaternion());
     }
     /**
-     * Rotate this quaternion by the given angle around the Z-axis.
-     * @param r - The angle in radians.
-     * @param out - The quaternion to store the result in.
-     * @returns The rotated quaternion.
+     * Perform a linear interpolation between this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @param t - The interpolation amount (in `[0,1]`).
+     * @returns The interpolated quaternion.
      */
-    rotateZ(r, out = new Quaternion()) {
-        return rotateZ(this, r, out);
+    lerp(quaternion, t) {
+        return lerp(this, quaternion, t, new Quaternion());
     }
     /**
-     * Calculate the fourth component of this unit quaternion from the first three, ignoring the existing fourth component.
-     * @param out - The quaternion to store the result in.
-     * @returns The quaternion.
+     * Calculate the natural logarithm of this unit quaternion.
+     * @returns The natural logarithm.
      */
-    calculateW(out = new Quaternion()) {
-        return calculateW(this, out);
+    ln() {
+        return ln(this, new Quaternion());
     }
     /**
-     * Calculate the exponential of this unit quaternion.
-     * @param out - The quaternion to store the result in.
-     * @returns The exponential.
+     * Multiply this and another quaternion.
+     * @param quaternion - The other quaternion.
+     * @returns The product.
      */
-    exp(out = new Quaternion()) {
-        return exp(this, out);
+    multiply(quaternion) {
+        return multiply(this, quaternion, new Quaternion());
     }
     /**
-     * Calculate the natural logarithm of this unit quaternion.
-     * @param out - The quaternion to store the result in.
-     * @returns The natural logarithm.
+     * Normalize this quaternion.
+     * @returns The normalized quaternion.
      */
-    ln(out = new Quaternion()) {
-        return ln(this, out);
+    normalize() {
+        return normalize(this, new Quaternion());
     }
     /**
      * Calculate a power of this unit quaternion.
      * @param scalar - The amount to scale the quaternion by.
-     * @param out - The quaternion to store the result in.
      * @returns The power.
      */
-    pow(scalar, out = new Quaternion()) {
-        return pow(this, scalar, out);
-    }
-    /**
-     * Perform a spherical linear interpolation between this and another quaternion.
-     * @param quaternion - The other quaternion.
-     * @param t - The interpolation amount in `[0,1]`.
-     * @param out - The quaternion to store the result in.
-     * @returns The interpolated quaternion.
-     * @see {@link https://en.wikipedia.org/wiki/Slerp | Slerp}
-     */
-    slerp(quaternion, t, out = new Quaternion()) {
-        return slerp(this, quaternion, t, out);
+    pow(scalar) {
+        return pow(this, scalar, new Quaternion());
     }
     /**
      * Set this to a random unit quaternion.
@@ -872,104 +915,46 @@ export default class Quaternion extends Float32Array {
         return random(this);
     }
     /**
-     * Calculate the inverse of this quaternion. If the quaternion is normalized, the conjugate is the same but faster to calculate.
-     * @param out - The quaternion to store the result in.
-     * @returns The inverse.
-     */
-    invert(out = new Quaternion()) {
-        return invert(this, out);
-    }
-    /**
-     * Calculate the conjugate of this quaternion. If the quaternion is normalized, this is the same as the inverse but faster to calculate.
-     * @param out - The quaternion to store the result in.
-     * @returns The conjugate.
-     */
-    conjugate(out = new Quaternion()) {
-        return conjugate(this, out);
-    }
-    /**
-     * Copy the values from this quaternion to another one.
-     * @param out - The quaternion to store the result in.
-     * @returns The copy.
+     * Rotate this quaternion by the given angle around the X-axis.
+     * @param r - The angle in radians.
+     * @returns The rotated quaternion.
      */
-    clone(out = new Quaternion()) {
-        return copy(this, out);
+    rotateX(r) {
+        return rotateX(this, r, new Quaternion());
     }
     /**
-     * Copy the values of another quaternion into this one.
-     * @param quaternion - The quaternion to copy.
-     * @returns This quaternion.
+     * Rotate this quaternion by the given angle around the Y-axis.
+     * @param r - The angle in radians.
+     * @returns The rotated quaternion.
      */
-    copy(quaternion) {
-        return copy(quaternion, this);
+    rotateY(r) {
+        return rotateY(this, r, new Quaternion());
     }
     /**
-     * Add two quaternions of the same size.
-     * @param quaternion - The other quaternion.
-     * @param out - The quaternion to store the result in.
-     * @returns The sum of the quaternions.
+     * Rotate this quaternion by the given angle around the Z-axis.
+     * @param r - The angle in radians.
+     * @returns The rotated quaternion.
      */
-    add(quaternion, out = new Quaternion()) {
-        return add(this, quaternion, out);
+    rotateZ(r) {
+        return rotateZ(this, r, new Quaternion());
     }
     /**
      * Scale this quaternion by a scalar.
      * @param scalar - The scalar.
-     * @param out - The quaternion to store the result in.
      * @returns The scaled quaternion.
      */
-    scale(scalar, out = new Quaternion()) {
-        return scale(this, scalar, out);
-    }
-    /**
-     * Calculate the dot product of this and another quaternion.
-     * @param quaternion - The other quaternion.
-     * @returns The dot product.
-     */
-    dot(quaternion) {
-        return dot(this, quaternion);
+    scale(scalar) {
+        return scale(this, scalar, new Quaternion());
     }
     /**
-     * Perform a linear interpolation between this and another quaternion.
+     * Perform a spherical linear interpolation between this and another quaternion.
      * @param quaternion - The other quaternion.
-     * @param t - The interpolation amount (in `[0,1]`).
-     * @param out - The quaternion to store the result in.
+     * @param t - The interpolation amount in `[0,1]`.
      * @returns The interpolated quaternion.
+     * @see {@link https://en.wikipedia.org/wiki/Slerp | Slerp}
      */
-    lerp(quaternion, t, out = new Quaternion()) {
-        return lerp(this, quaternion, t, out);
-    }
-    /** Get the magnitude (length) of this quaternion. */
-    get magnitude() {
-        return getMagnitude(this);
-    }
-    /** Get the squared magnitude (length) of this quaternion. */
-    get squaredMagnitude() {
-        return getSquaredMagnitude(this);
-    }
-    /**
-     * Normalize this quaternion.
-     * @param out - The quaternion to store the result in.
-     * @returns The normalized quaternion.
-     */
-    normalize(out = new Quaternion()) {
-        return normalize(this, out);
-    }
-    /**
-     * Determine whether or not this quaternion is roughly equivalent to another.
-     * @param quaternion - The other quaternion.
-     * @returns Whether or not the quaternions are equivalent.
-     */
-    equals(quaternion) {
-        return equals(this, quaternion);
-    }
-    /**
-     * Determine whether or not this quaternion is exactly equivalent to another.
-     * @param quaternion - The other quaternion.
-     * @returns Whether or not the quaternions are equivalent.
-     */
-    exactEquals(quaternion) {
-        return exactEquals(this, quaternion);
+    slerp(quaternion, t) {
+        return slerp(this, quaternion, t, new Quaternion());
     }
     /**
      * Perform a spherical linear interpolation with two control points between this and another quaternion.
@@ -977,20 +962,18 @@ export default class Quaternion extends Float32Array {
      * @param b - The second control point.
      * @param quaternion - The other quaternion.
      * @param t - The interpolation amount in `[0,1]`.
-     * @param out - The quaternion to store the result in.
      * @returns The interpolated value.
      * @see {@link https://en.wikipedia.org/wiki/Slerp | Slerp}
      */
-    sqlerp(a, b, quaternion, t, out = new Quaternion()) {
-        return sqlerp(this, a, b, quaternion, t, out);
+    sqlerp(a, b, quaternion, t) {
+        return sqlerp(this, a, b, quaternion, t, new Quaternion());
     }
     /**
      * Convert this quaternion to equivalent z-y'-x" (intrinsic) Tait-Bryan angles.
-     * @param out - The vector in which to store the Tait-Bryan angles.
      * @returns The Tait-Bryan angles in degrees in roll (z), pitch (y'), yaw (x") order.
      */
-    toEuler(out = new Vector3()) {
-        return toEuler(this, out);
+    toEuler() {
+        return toEuler(this, new Vector3());
     }
 }
 //# sourceMappingURL=Quaternion.js.map