@faicad/faijs 0.31.1 → 0.32.3

package/dist/math3d/Plane.js

@@ -0,0 +1,90 @@
+/**
+   * math3d/Plane — three.js r162 `Plane` 的算法子集移植。
+ *
+   * Ported from three.js r162 `src/math/Plane.js` (MIT License, © 2010-2024
+   * three.js authors). 平面方程 `normal · p + constant = 0` 与 three 一致。
+   * 未移植 `intersectLine` / `intersectsBox`（core 不用；需要时再补，别顺手加）。
+ */
+import { Vec3 } from './Vec3.js';
+/** Plane (normal, constant), three.js `Plane` subset. */
+export class Plane {
+    /** three 内部标记。 */
+    isPlane = true;
+    /** Unit normal of the plane. */
+    normal;
+    /** Signed distance from the origin along the normal. */
+    constant;
+    /**
+     * @param normal - unit normal.
+     * @param constant - plane constant (normal · p + constant = 0).
+     */
+    constructor(normal = new Vec3(1, 0, 0), constant = 0) {
+        this.normal = normal;
+        this.constant = constant;
+    }
+    /**
+     * Set the normal and constant.
+     * @param normal - unit normal.
+     * @param constant - plane constant.
+     * @returns this
+     */
+    set(normal, constant) {
+        this.normal.copy(normal);
+        this.constant = constant;
+        return this;
+    }
+    /**
+     * Set from a normal and a point on the plane.
+     * @param normal - unit normal.
+     * @param point - a point on the plane.
+     * @returns this
+     */
+    setFromNormalAndCoplanarPoint(normal, point) {
+        this.normal.copy(normal);
+        this.constant = -point.dot(this.normal);
+        return this;
+    }
+    /**
+     * Copy from another plane.
+     * @param plane - source plane.
+     * @returns this
+     */
+    copy(plane) {
+        this.normal.copy(plane.normal);
+        this.constant = plane.constant;
+        return this;
+    }
+    /**
+     * Return a new plane with the same values.
+     * @returns a new plane with the same normal and constant.
+     */
+    clone() {
+        return new Plane().copy(this);
+    }
+    /**
+     * Return the signed distance to a point.
+     * @param point - the point to measure.
+     * @returns the signed distance from the plane.
+     */
+    distanceToPoint(point) {
+        return this.normal.dot(point) + this.constant;
+    }
+    /**
+     * Project a point onto the plane.
+     * @param point - the point to project.
+     * @param target - the output vector.
+     * @returns the projected point (stored in target).
+     */
+    projectPoint(point, target) {
+        return target.copy(point).addScaledVector(this.normal, -this.distanceToPoint(point));
+    }
+    /**
+     * Return a point on the plane.
+     * @param target - the output vector.
+     * @returns an arbitrary point on the plane (stored in target).
+     */
+    coplanarPoint(target) {
+        return target.copy(this.normal).multiplyScalar(-this.constant);
+    }
+}
+//# sourceMappingURL=Plane.js.map

package/dist/math3d/Plane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Plane.js","sourceRoot":"","sources":["../../src/math3d/Plane.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B,yDAAyD;AACzD,MAAM,OAAO,KAAK;IAChB,kBAAkB;IACT,OAAO,GAAG,IAAI,CAAA;IAEvB,gCAAgC;IAChC,MAAM,CAAM;IACZ,wDAAwD;IACxD,QAAQ,CAAQ;IAEhB;;;OAGG;IACH,YAAY,SAAe,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,MAAY,EAAE,QAAgB;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;OAKG;IACH,6BAA6B,CAAC,MAAY,EAAE,KAAW;QACrD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACvC,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,KAAY;QACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;QAC9B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAA;QAC9B,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,IAAI,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAC,KAAW;QACzB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAA;IAC/C,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,KAAW,EAAE,MAAY;QACpC,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAA;IACtF,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,MAAY;QACxB,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAChE,CAAC;CACF","sourcesContent":["/**\r\n   * math3d/Plane — three.js r162 `Plane` 的算法子集移植。\r\n *\r\n   * Ported from three.js r162 `src/math/Plane.js` (MIT License, © 2010-2024\r\n   * three.js authors). 平面方程 `normal · p + constant = 0` 与 three 一致。\r\n   * 未移植 `intersectLine` / `intersectsBox`（core 不用；需要时再补，别顺手加）。\r\n */\r\n\r\nimport { Vec3 } from './Vec3'\r\n\r\n/** Plane (normal, constant), three.js `Plane` subset. */\r\nexport class Plane {\r\n  /** three 内部标记。 */\r\n  readonly isPlane = true\r\n\r\n  /** Unit normal of the plane. */\n  normal: Vec3\r\n  /** Signed distance from the origin along the normal. */\n  constant: number\r\n\r\n  /**\r\n   * @param normal - unit normal.\r\n   * @param constant - plane constant (normal · p + constant = 0).\r\n   */\r\n  constructor(normal: Vec3 = new Vec3(1, 0, 0), constant = 0) {\r\n    this.normal = normal\r\n    this.constant = constant\r\n  }\r\n\r\n  /**\r\n   * Set the normal and constant.\n   * @param normal - unit normal.\r\n   * @param constant - plane constant.\r\n   * @returns this\r\n   */\r\n  set(normal: Vec3, constant: number): this {\r\n    this.normal.copy(normal)\r\n    this.constant = constant\r\n    return this\r\n  }\r\n\r\n  /**\r\n   * Set from a normal and a point on the plane.\n   * @param normal - unit normal.\r\n   * @param point - a point on the plane.\r\n   * @returns this\r\n   */\r\n  setFromNormalAndCoplanarPoint(normal: Vec3, point: Vec3): this {\r\n    this.normal.copy(normal)\r\n    this.constant = -point.dot(this.normal)\r\n    return this\r\n  }\r\n\r\n  /**\r\n   * Copy from another plane.\n   * @param plane - source plane.\r\n   * @returns this\r\n   */\r\n  copy(plane: Plane): this {\r\n    this.normal.copy(plane.normal)\r\n    this.constant = plane.constant\r\n    return this\r\n  }\r\n\r\n  /**\r\n   * Return a new plane with the same values.\n   * @returns a new plane with the same normal and constant.\r\n   */\r\n  clone(): Plane {\r\n    return new Plane().copy(this)\r\n  }\r\n\r\n  /**\r\n   * Return the signed distance to a point.\n   * @param point - the point to measure.\r\n   * @returns the signed distance from the plane.\r\n   */\r\n  distanceToPoint(point: Vec3): number {\r\n    return this.normal.dot(point) + this.constant\r\n  }\r\n\r\n  /**\r\n   * Project a point onto the plane.\n   * @param point - the point to project.\r\n   * @param target - the output vector.\r\n   * @returns the projected point (stored in target).\r\n   */\r\n  projectPoint(point: Vec3, target: Vec3): Vec3 {\r\n    return target.copy(point).addScaledVector(this.normal, -this.distanceToPoint(point))\r\n  }\r\n\r\n  /**\r\n   * Return a point on the plane.\n   * @param target - the output vector.\r\n   * @returns an arbitrary point on the plane (stored in target).\r\n   */\r\n  coplanarPoint(target: Vec3): Vec3 {\r\n    return target.copy(this.normal).multiplyScalar(-this.constant)\r\n  }\r\n}"]}

package/dist/math3d/Quat.d.ts

@@ -0,0 +1,163 @@
+/**
+   * math3d/Quat — three.js r162 `Quaternion` 的算法子集移植。
+ *
+   * Ported from three.js r162 `src/math/Quaternion.js` (MIT License, © 2010-2024
+   * three.js authors). 公式与运算顺序逐行照抄以保证逐位一致；`_onChange`
+   * 回调机制（three 的渲染用）未移植——本类只做数学。
+ */
+import type { Vec3 } from './Vec3.js';
+/** Quaternion (x, y, z, w), three.js `Quaternion` subset. */
+export declare class Quat {
+    /** X component. */
+    x: number;
+    /** Y component. */
+    y: number;
+    /** Z component. */
+    z: number;
+    /** W (scalar) component. */
+    w: number;
+    /**
+     * @param x - X component.
+     * @param y - Y component.
+     * @param z - Z component.
+     * @param w - W (scalar) component.
+     */
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /**
+     * Set the component values.
+     * @param x - X component.
+     * @param y - Y component.
+     * @param z - Z component.
+     * @param w - W (scalar) component.
+     * @returns this
+     */
+    set(x: number, y: number, z: number, w: number): this;
+    /**
+     * Copy the components from another quaternion.
+     * @param q - source quaternion.
+     * @returns this
+     */
+    copy(q: Quat): this;
+    /**
+     * Return a new quaternion with the same components.
+     * @returns a new quaternion with the same components.
+     */
+    clone(): Quat;
+    /**
+     * Set to the identity quaternion.
+     * @returns this (identity quaternion)
+     */
+    identity(): this;
+    /**
+     * Set from Euler angles (radians) with an order tag.
+     * @param euler - Euler angles (radians) with an order tag.
+     * @returns this
+     */
+    setFromEuler(euler: {
+        x: number;
+        y: number;
+        z: number;
+        order: string;
+    }): this;
+    /**
+     * Set from an axis and an angle (radians).
+     * @param axis - rotation axis (unit length assumed).
+     * @param angle - rotation angle in radians.
+     * @returns this
+     */
+    setFromAxisAngle(axis: Vec3, angle: number): this;
+    /**
+     * Set from a rotation matrix.
+     * @param m - matrix whose upper 3x3 is a pure rotation (column-major elements).
+     * @returns this
+     */
+    setFromRotationMatrix(m: {
+        elements: number[];
+    }): this;
+    /**
+     * Set to the rotation from unit vector v1 to v2.
+     * @param vFrom - source direction (unit length assumed).
+     * @param vTo - target direction (unit length assumed).
+     * @returns this
+     */
+    setFromUnitVectors(vFrom: Vec3, vTo: Vec3): this;
+    /**
+     * Multiply by another quaternion (this = this * q).
+     * @param q - right operand.
+     * @returns this
+     */
+    multiply(q: Quat): this;
+    /**
+     * Pre-multiply by another quaternion (this = q * this).
+     * @param q - left operand.
+     * @returns this
+     */
+    premultiply(q: Quat): this;
+    /**
+     * Set this to a * b.
+     * @param a - left operand.
+     * @param b - right operand.
+     * @returns this
+     */
+    multiplyQuaternions(a: Quat, b: Quat): this;
+    /**
+     * Spherical-interpolate towards qb by t.
+     * @param qb - target quaternion.
+     * @param t - interpolation factor.
+     * @returns this
+     */
+    slerp(qb: Quat, t: number): this;
+    /**
+     * Return the dot product with another quaternion.
+     * @param q - quaternion to compare with.
+     * @returns the dot product.
+     */
+    dot(q: Quat): number;
+    /**
+     * Return the 4D length.
+     * @returns the quaternion length.
+     */
+    length(): number;
+    /**
+     * Scale to unit length (zero-length stays zero).
+     * @returns this
+     */
+    normalize(): this;
+    /**
+     * Invert in place (conjugate for unit quaternions).
+     * @returns this (assumes unit length)
+     */
+    invert(): this;
+    /**
+     * Conjugate in place (negate x, y, z).
+     * @returns this
+     */
+    conjugate(): this;
+    /**
+     * Return the angle (radians) to another quaternion.
+     * @param q - quaternion to compare with.
+     * @returns the angle in radians.
+     */
+    angleTo(q: Quat): number;
+    /**
+     * Write the components into an array.
+     * @param array - target array (created when omitted).
+     * @param offset - start offset.
+     * @returns the target array.
+     */
+    toArray(array?: number[], offset?: number): number[];
+    /**
+     * Load the components from an array-like.
+     * @param array - source array.
+     * @param offset - start offset.
+     * @returns this
+     */
+    fromArray(array: ArrayLike<number>, offset?: number): this;
+    /**
+     * Return true when all components are exactly equal.
+     * @param q - quaternion to compare with.
+     * @returns true when all components are strictly equal.
+     */
+    equals(q: Quat): boolean;
+}
+//# sourceMappingURL=Quat.d.ts.map

package/dist/math3d/Quat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Quat.d.ts","sourceRoot":"","sources":["../../src/math3d/Quat.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,6DAA6D;AAC7D,qBAAa,IAAI;IACf,mBAAmB;IACnB,CAAC,EAAE,MAAM,CAAA;IACT,mBAAmB;IACnB,CAAC,EAAE,MAAM,CAAA;IACT,mBAAmB;IACnB,CAAC,EAAE,MAAM,CAAA;IACT,4BAA4B;IAC5B,CAAC,EAAE,MAAM,CAAA;IAET;;;;;OAKG;gBACS,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI;IAOtC;;;;;;;OAOG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAQrD;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAQnB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAIb;;;OAGG;IACH,QAAQ,IAAI,IAAI;IAIhB;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAuD7E;;;;;OAKG;IACH,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAUjD;;;;OAIG;IACH,qBAAqB,CAAC,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI;IAyCtD;;;;;OAKG;IACH,kBAAkB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI;IAwBhD;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAIvB;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B;;;;;OAKG;IACH,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI;IAgB3C;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IA6ChC;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM;IAIpB;;;OAGG;IACH,MAAM,IAAI,MAAM;IAIhB;;;OAGG;IACH,SAAS,IAAI,IAAI;IAiBjB;;;OAGG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,SAAS,IAAI,IAAI;IAOjB;;;;OAIG;IACH,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM;IAIxB;;;;;OAKG;IACH,OAAO,CAAC,KAAK,GAAE,MAAM,EAAO,EAAE,MAAM,SAAI,GAAG,MAAM,EAAE;IAQnD;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,SAAI,GAAG,IAAI;IAQrD;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO;CAGzB"}

package/dist/math3d/Quat.js

@@ -0,0 +1,408 @@
+/**
+   * math3d/Quat — three.js r162 `Quaternion` 的算法子集移植。
+ *
+   * Ported from three.js r162 `src/math/Quaternion.js` (MIT License, © 2010-2024
+   * three.js authors). 公式与运算顺序逐行照抄以保证逐位一致；`_onChange`
+   * 回调机制（three 的渲染用）未移植——本类只做数学。
+ */
+/** Quaternion (x, y, z, w), three.js `Quaternion` subset. */
+export class Quat {
+    /** X component. */
+    x;
+    /** Y component. */
+    y;
+    /** Z component. */
+    z;
+    /** W (scalar) component. */
+    w;
+    /**
+     * @param x - X component.
+     * @param y - Y component.
+     * @param z - Z component.
+     * @param w - W (scalar) component.
+     */
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    /**
+     * Set the component values.
+     * @param x - X component.
+     * @param y - Y component.
+     * @param z - Z component.
+     * @param w - W (scalar) component.
+     * @returns this
+     */
+    set(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    }
+    /**
+     * Copy the components from another quaternion.
+     * @param q - source quaternion.
+     * @returns this
+     */
+    copy(q) {
+        this.x = q.x;
+        this.y = q.y;
+        this.z = q.z;
+        this.w = q.w;
+        return this;
+    }
+    /**
+     * Return a new quaternion with the same components.
+     * @returns a new quaternion with the same components.
+     */
+    clone() {
+        return new Quat(this.x, this.y, this.z, this.w);
+    }
+    /**
+     * Set to the identity quaternion.
+     * @returns this (identity quaternion)
+     */
+    identity() {
+        return this.set(0, 0, 0, 1);
+    }
+    /**
+     * Set from Euler angles (radians) with an order tag.
+     * @param euler - Euler angles (radians) with an order tag.
+     * @returns this
+     */
+    setFromEuler(euler) {
+        const x = euler.x;
+        const y = euler.y;
+        const z = euler.z;
+        const order = euler.order;
+        const cos = Math.cos;
+        const sin = Math.sin;
+        const c1 = cos(x / 2);
+        const c2 = cos(y / 2);
+        const c3 = cos(z / 2);
+        const s1 = sin(x / 2);
+        const s2 = sin(y / 2);
+        const s3 = sin(z / 2);
+        switch (order) {
+            case 'XYZ':
+                this.x = s1 * c2 * c3 + c1 * s2 * s3;
+                this.y = c1 * s2 * c3 - s1 * c2 * s3;
+                this.z = c1 * c2 * s3 + s1 * s2 * c3;
+                this.w = c1 * c2 * c3 - s1 * s2 * s3;
+                break;
+            case 'YXZ':
+                this.x = s1 * c2 * c3 + c1 * s2 * s3;
+                this.y = c1 * s2 * c3 - s1 * c2 * s3;
+                this.z = c1 * c2 * s3 - s1 * s2 * c3;
+                this.w = c1 * c2 * c3 + s1 * s2 * s3;
+                break;
+            case 'ZXY':
+                this.x = s1 * c2 * c3 - c1 * s2 * s3;
+                this.y = c1 * s2 * c3 + s1 * c2 * s3;
+                this.z = c1 * c2 * s3 + s1 * s2 * c3;
+                this.w = c1 * c2 * c3 - s1 * s2 * s3;
+                break;
+            case 'ZYX':
+                this.x = s1 * c2 * c3 - c1 * s2 * s3;
+                this.y = c1 * s2 * c3 + s1 * c2 * s3;
+                this.z = c1 * c2 * s3 - s1 * s2 * c3;
+                this.w = c1 * c2 * c3 + s1 * s2 * s3;
+                break;
+            case 'YZX':
+                this.x = s1 * c2 * c3 + c1 * s2 * s3;
+                this.y = c1 * s2 * c3 + s1 * c2 * s3;
+                this.z = c1 * c2 * s3 - s1 * s2 * c3;
+                this.w = c1 * c2 * c3 - s1 * s2 * s3;
+                break;
+            case 'XZY':
+                this.x = s1 * c2 * c3 - c1 * s2 * s3;
+                this.y = c1 * s2 * c3 - s1 * c2 * s3;
+                this.z = c1 * c2 * s3 + s1 * s2 * c3;
+                this.w = c1 * c2 * c3 + s1 * s2 * s3;
+                break;
+        }
+        return this;
+    }
+    /**
+     * Set from an axis and an angle (radians).
+     * @param axis - rotation axis (unit length assumed).
+     * @param angle - rotation angle in radians.
+     * @returns this
+     */
+    setFromAxisAngle(axis, angle) {
+        const halfAngle = angle / 2;
+        const s = Math.sin(halfAngle);
+        this.x = axis.x * s;
+        this.y = axis.y * s;
+        this.z = axis.z * s;
+        this.w = Math.cos(halfAngle);
+        return this;
+    }
+    /**
+     * Set from a rotation matrix.
+     * @param m - matrix whose upper 3x3 is a pure rotation (column-major elements).
+     * @returns this
+     */
+    setFromRotationMatrix(m) {
+        const te = m.elements;
+        const m11 = te[0];
+        const m12 = te[4];
+        const m13 = te[8];
+        const m21 = te[1];
+        const m22 = te[5];
+        const m23 = te[9];
+        const m31 = te[2];
+        const m32 = te[6];
+        const m33 = te[10];
+        const trace = m11 + m22 + m33;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1.0);
+            this.w = 0.25 / s;
+            this.x = (m32 - m23) * s;
+            this.y = (m13 - m31) * s;
+            this.z = (m21 - m12) * s;
+        }
+        else if (m11 > m22 && m11 > m33) {
+            const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+            this.w = (m32 - m23) / s;
+            this.x = 0.25 * s;
+            this.y = (m12 + m21) / s;
+            this.z = (m13 + m31) / s;
+        }
+        else if (m22 > m33) {
+            const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+            this.w = (m13 - m31) / s;
+            this.x = (m12 + m21) / s;
+            this.y = 0.25 * s;
+            this.z = (m23 + m32) / s;
+        }
+        else {
+            const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+            this.w = (m21 - m12) / s;
+            this.x = (m13 + m31) / s;
+            this.y = (m23 + m32) / s;
+            this.z = 0.25 * s;
+        }
+        return this;
+    }
+    /**
+     * Set to the rotation from unit vector v1 to v2.
+     * @param vFrom - source direction (unit length assumed).
+     * @param vTo - target direction (unit length assumed).
+     * @returns this
+     */
+    setFromUnitVectors(vFrom, vTo) {
+        let r = vFrom.dot(vTo) + 1;
+        if (r < Number.EPSILON) {
+            r = 0;
+            if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+                this.x = -vFrom.y;
+                this.y = vFrom.x;
+                this.z = 0;
+                this.w = r;
+            }
+            else {
+                this.x = 0;
+                this.y = -vFrom.z;
+                this.z = vFrom.y;
+                this.w = r;
+            }
+        }
+        else {
+            this.x = vFrom.y * vTo.z - vFrom.z * vTo.y;
+            this.y = vFrom.z * vTo.x - vFrom.x * vTo.z;
+            this.z = vFrom.x * vTo.y - vFrom.y * vTo.x;
+            this.w = r;
+        }
+        return this.normalize();
+    }
+    /**
+     * Multiply by another quaternion (this = this * q).
+     * @param q - right operand.
+     * @returns this
+     */
+    multiply(q) {
+        return this.multiplyQuaternions(this, q);
+    }
+    /**
+     * Pre-multiply by another quaternion (this = q * this).
+     * @param q - left operand.
+     * @returns this
+     */
+    premultiply(q) {
+        return this.multiplyQuaternions(q, this);
+    }
+    /**
+     * Set this to a * b.
+     * @param a - left operand.
+     * @param b - right operand.
+     * @returns this
+     */
+    multiplyQuaternions(a, b) {
+        const qax = a.x;
+        const qay = a.y;
+        const qaz = a.z;
+        const qaw = a.w;
+        const qbx = b.x;
+        const qby = b.y;
+        const qbz = b.z;
+        const qbw = b.w;
+        this.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+        this.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+        this.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+        this.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+        return this;
+    }
+    /**
+     * Spherical-interpolate towards qb by t.
+     * @param qb - target quaternion.
+     * @param t - interpolation factor.
+     * @returns this
+     */
+    slerp(qb, t) {
+        if (t === 0)
+            return this;
+        if (t === 1)
+            return this.copy(qb);
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
+        const w = this.w;
+        let cosHalfTheta = w * qb.w + x * qb.x + y * qb.y + z * qb.z;
+        if (cosHalfTheta < 0) {
+            this.w = -qb.w;
+            this.x = -qb.x;
+            this.y = -qb.y;
+            this.z = -qb.z;
+            cosHalfTheta = -cosHalfTheta;
+        }
+        else {
+            this.copy(qb);
+        }
+        if (cosHalfTheta >= 1.0) {
+            this.w = w;
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            return this;
+        }
+        const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
+        if (sqrSinHalfTheta <= Number.EPSILON) {
+            const s = 1 - t;
+            this.w = s * w + t * this.w;
+            this.x = s * x + t * this.x;
+            this.y = s * y + t * this.y;
+            this.z = s * z + t * this.z;
+            this.normalize();
+            return this;
+        }
+        const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
+        const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
+        const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
+        const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+        this.w = w * ratioA + this.w * ratioB;
+        this.x = x * ratioA + this.x * ratioB;
+        this.y = y * ratioA + this.y * ratioB;
+        this.z = z * ratioA + this.z * ratioB;
+        return this;
+    }
+    /**
+     * Return the dot product with another quaternion.
+     * @param q - quaternion to compare with.
+     * @returns the dot product.
+     */
+    dot(q) {
+        return this.x * q.x + this.y * q.y + this.z * q.z + this.w * q.w;
+    }
+    /**
+     * Return the 4D length.
+     * @returns the quaternion length.
+     */
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    }
+    /**
+     * Scale to unit length (zero-length stays zero).
+     * @returns this
+     */
+    normalize() {
+        let l = this.length();
+        if (l === 0) {
+            this.x = 0;
+            this.y = 0;
+            this.z = 0;
+            this.w = 1;
+        }
+        else {
+            l = 1 / l;
+            this.x = this.x * l;
+            this.y = this.y * l;
+            this.z = this.z * l;
+            this.w = this.w * l;
+        }
+        return this;
+    }
+    /**
+     * Invert in place (conjugate for unit quaternions).
+     * @returns this (assumes unit length)
+     */
+    invert() {
+        return this.conjugate();
+    }
+    /**
+     * Conjugate in place (negate x, y, z).
+     * @returns this
+     */
+    conjugate() {
+        this.x *= -1;
+        this.y *= -1;
+        this.z *= -1;
+        return this;
+    }
+    /**
+     * Return the angle (radians) to another quaternion.
+     * @param q - quaternion to compare with.
+     * @returns the angle in radians.
+     */
+    angleTo(q) {
+        return 2 * Math.acos(Math.abs(Math.max(-1, Math.min(1, this.dot(q)))));
+    }
+    /**
+     * Write the components into an array.
+     * @param array - target array (created when omitted).
+     * @param offset - start offset.
+     * @returns the target array.
+     */
+    toArray(array = [], offset = 0) {
+        array[offset] = this.x;
+        array[offset + 1] = this.y;
+        array[offset + 2] = this.z;
+        array[offset + 3] = this.w;
+        return array;
+    }
+    /**
+     * Load the components from an array-like.
+     * @param array - source array.
+     * @param offset - start offset.
+     * @returns this
+     */
+    fromArray(array, offset = 0) {
+        this.x = array[offset];
+        this.y = array[offset + 1];
+        this.z = array[offset + 2];
+        this.w = array[offset + 3];
+        return this;
+    }
+    /**
+     * Return true when all components are exactly equal.
+     * @param q - quaternion to compare with.
+     * @returns true when all components are strictly equal.
+     */
+    equals(q) {
+        return q.x === this.x && q.y === this.y && q.z === this.z && q.w === this.w;
+    }
+}
+//# sourceMappingURL=Quat.js.map