@mlightcad/geometry-engine 1.0.0

package/lib/math/AcGeQuaternion.d.ts

@@ -0,0 +1,230 @@
+import { AcGeEuler } from './AcGeEuler';
+import { AcGeMatrix3d } from './AcGeMatrix3d';
+import { AcGeVector3d, AcGeVector3dLike } from './AcGeVector3d';
+export declare class AcGeQuaternion {
+    private _x;
+    private _y;
+    private _z;
+    private _w;
+    /**
+     * Create one instance of this class
+     * @param x Input x coordinate
+     * @param y Input y coordinate
+     * @param z Input z coordinate
+     * @param w Input w coordinate
+     */
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /**
+     * This SLERP implementation assumes the quaternion data are managed in flat arrays.
+     * @param dst Input the output array
+     * @param dstOffset Input an offset into the output array
+     * @param src0 Input the source array of the starting quaternion.
+     * @param srcOffset0 Input an offset into the array src0.
+     * @param src1 Input the source array of the target quaternion.
+     * @param srcOffset1 Input an offset into the array src1.
+     * @param t Input normalized interpolation factor (between 0 and 1).
+     */
+    static slerpFlat(dst: number[], dstOffset: number, src0: number[], srcOffset0: number, src1: number[], srcOffset1: number, t: number): void;
+    /**
+     * This multiplication implementation assumes the quaternion data are managed in flat arrays.
+     * @param dst Input the output array.
+     * @param dstOffset Input an offset into the output array.
+     * @param src0 Input the source array of the starting quaternion.
+     * @param srcOffset0 Input an offset into the array src0.
+     * @param src1 Input the source array of the target quaternion.
+     * @param srcOffset1 Input an offset into the array src1.
+     * @returns Return an array
+     */
+    static multiplyQuaternionsFlat(dst: number[], dstOffset: number, src0: number[], srcOffset0: number, src1: number[], srcOffset1: number): number[];
+    /**
+     * X cooridinate
+     */
+    get x(): number;
+    set x(value: number);
+    /**
+     * Y cooridinate
+     */
+    get y(): number;
+    set y(value: number);
+    /**
+     * Z cooridinate
+     */
+    get z(): number;
+    set z(value: number);
+    /**
+     * W cooridinate
+     */
+    get w(): number;
+    set w(value: number);
+    /**
+     * Set x, y, z, w properties of this quaternion.
+     * @param x Input x coordinate
+     * @param y Input y coordinate
+     * @param z Input z coordinate
+     * @param w Input w coordinate
+     * @returns Return this quaternion
+     */
+    set(x: number, y: number, z: number, w: number): this;
+    /**
+     * Create a new quaternion with identical x, y, z and w properties to this one.
+     * @returns Return cloned instance
+     */
+    clone(): AcGeQuaternion;
+    /**
+     * Copy the x, y, z and w properties of q into this quaternion.
+     * @param quaternion Input the quaternion copied from
+     * @returns Return this quaternion
+     */
+    copy(quaternion: AcGeQuaternion): this;
+    /**
+     * Sets this quaternion from the rotation specified by euler angle.
+     * @param euler Input one euler angle
+     * @param update Input one flag whether to trigger change callback function
+     * @returns Return this quaternion
+     */
+    setFromEuler(euler: AcGeEuler, update?: boolean): this;
+    /**
+     * Set this quaternion from rotation specified by axis and angle. Axis is assumed to be normalized,
+     * angle is in radians.
+     * @param axis Input one normalized axis
+     * @param angle Input one angle in radians
+     * @returns Return this quaternion
+     */
+    setFromAxisAngle(axis: AcGeVector3dLike, angle: number): this;
+    /**
+     * Set this quaternion from rotation component of the specified matrix.
+     * @param m Input a Matrix4 of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
+     * @returns Return this quaternion
+     */
+    setFromRotationMatrix(m: AcGeMatrix3d): this;
+    /**
+     * Set this quaternion to the rotation required to rotate direction vector vFrom to direction vector vTo.
+     * @param vFrom Input one normalized direction vector
+     * @param vTo Input one normalized direction vector
+     * @returns Return this quaternion
+     */
+    setFromUnitVectors(vFrom: AcGeVector3d, vTo: AcGeVector3d): this;
+    /**
+     * Return the angle between this quaternion and quaternion q in radians.
+     * @param q Input one quaternion
+     * @returns Return the angle between this quaternion and quaternion q in radians.
+     */
+    angleTo(q: AcGeQuaternion): number;
+    /**
+     * Rotate this quaternion by a given angular step to the defined quaternion q. The method ensures
+     * that the final quaternion will not overshoot q.
+     * @param q Input the target quaternion.
+     * @param step Input the angular step in radians.
+     * @returns Return this quaternion
+     */
+    rotateTowards(q: AcGeQuaternion, step: number): this;
+    /**
+     * Set this quaternion to the identity quaternion; that is, to the quaternion that represents
+     * "no rotation".
+     * @returns Return this quaternion.
+     */
+    identity(): this;
+    /**
+     * Invert this quaternion - calculates the conjugate. The quaternion is assumed to have unit length.
+     * @returns Return this quaternion.
+     */
+    invert(): this;
+    /**
+     * Return the rotational conjugate of this quaternion. The conjugate of a quaternion represents the
+     * same rotation in the opposite direction about the rotational axis.
+     * @returns Return this quaternion
+     */
+    conjugate(): this;
+    /**
+     * Calculate the dot product of quaternions v and this one.
+     * @param v Input one quaternion
+     * @returns Return the dot product of quaternions v and this one
+     */
+    dot(v: AcGeQuaternion): number;
+    /**
+     * Compute the squared Euclidean length (straight-line length) of this quaternion, considered as a
+     * 4 dimensional vector. This can be useful if you are comparing the lengths of two quaternions, as
+     * this is a slightly more efficient calculation than length().
+     * @returns Return the squared Euclidean length (straight-line length) of this quaternion
+     */
+    lengthSq(): number;
+    /**
+     * Compute the Euclidean length (straight-line length) of this quaternion, considered as a 4 dimensional
+     * vector.
+     * @returns Return the Euclidean length (straight-line length) of this quaternion.
+     */
+    length(): number;
+    /**
+     * Normalize this quaternion - that is, calculated the quaternion that performs the same rotation as
+     * this one, but has length equal to 1.
+     * @returns Return this quaternion
+     */
+    normalize(): this;
+    /**
+     * Multiply this quaternion by q.
+     * @param q Input one quaternion to multiply
+     * @returns Return this quaternion
+     */
+    multiply(q: AcGeQuaternion): this;
+    /**
+     * Pre-multiply this quaternion by q.
+     * @param q Input one quaternion
+     * @returns Return this quaternion
+     */
+    premultiply(q: AcGeQuaternion): this;
+    /**
+     * Sets this quaternion to a x b.
+     * @param a Input one quaternion
+     * @param b Input one quaternion
+     * @returns Return this quaternion
+     */
+    multiplyQuaternions(a: AcGeQuaternion, b: AcGeQuaternion): this;
+    /**
+     * Handles the spherical linear interpolation between quaternions. t represents the amount of rotation
+     * between this quaternion (where t is 0) and qb (where t is 1).
+     * @param qb Input the other quaternion rotation
+     * @param t Input interpolation factor in the closed interval [0, 1].
+     * @returns Return this quaternion
+     */
+    slerp(qb: AcGeQuaternion, t: number): this;
+    /**
+     * Perform a spherical linear interpolation between the given quaternions and stores the result in
+     * this quaternion.
+     * @param qa Input one quaternion rotation
+     * @param qb Input the other quaternion rotation
+     * @param t Input interpolation factor in the closed interval [0, 1].
+     * @returns Return this quaternion
+     */
+    slerpQuaternions(qa: AcGeQuaternion, qb: AcGeQuaternion, t: number): this;
+    /**
+     * Set this quaternion to a uniformly random, normalized quaternion.
+     * @returns Return this quaternion
+     */
+    random(): this;
+    /**
+     * Compare the x, y, z and w properties of v to the equivalent properties of this quaternion to
+     * determine if they represent the same rotation.
+     * @param quaternion Input quaternion that this quaternion will be compared to.
+     * @returns Return true if the specified quaternion and this quaternion represent the same rotation.
+     */
+    equals(quaternion: AcGeQuaternion): boolean;
+    /**
+     * Set this quaternion's x, y, z and w properties from an array.
+     * @param array Input an array of format (x, y, z, w) used to construct the quaternion.
+     * @param offset Input an optional offset into the array
+     * @returns Return this quaternion
+     */
+    fromArray(array: number[], offset?: number): this;
+    /**
+     * Return the numerical elements of this quaternion in an array of format [x, y, z, w].
+     * @param array Input an optional array to store the quaternion. If not specified, a new array will be created.
+     * @param offset (optional) if specified, the result will be copied into this Array.
+     * @returns Return an array
+     */
+    toArray(array?: number[], offset?: number): number[];
+    toJSON(): number[];
+    _onChange(callback: () => void): this;
+    _onChangeCallback(): void;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+//# sourceMappingURL=AcGeQuaternion.d.ts.map

package/lib/math/AcGeQuaternion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcGeQuaternion.d.ts","sourceRoot":"","sources":["../../src/math/AcGeQuaternion.ts"],"names":[],"mappings":"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"}