linearly 0.0.0

package/lib/quat.d.ts

@@ -0,0 +1,218 @@
+import * as Common from './common';
+import type { Mat3 } from './mat3';
+import type { Vec3 } from './vec3';
+import * as vec4 from './vec4';
+export type Quat = readonly [number, number, number, number];
+/**
+ * Quaternion in the format XYZW
+ * @module quat
+ */
+/**
+ * The identity quaternion
+ */
+export declare const identity: Quat;
+/**
+ * Sets a quat from the given angle and rotation axis,
+ * then returns it.
+ *
+ * @param axis the axis around which to rotate
+ * @param rad the angle in radians
+ **/
+export declare function setAxisAngle(axis: Vec3, rad: number): Quat;
+interface AxisAngle {
+    axis: Vec3;
+    rad: number;
+}
+/**
+ * Gets the rotation axis and angle for a given
+ *  quaternion. If a quaternion is created with
+ *  setAxisAngle, this method will return the same
+ *  values as providied in the original parameter list
+ *  OR functionally equivalent values.
+ * Example: The quaternion formed by axis [0, 0, 1] and
+ *  angle -90 is the same as the quaternion formed by
+ *  [0, 0, 1] and 270. This method favors the latter.
+ *
+ * @param  q Quaternion to be decomposed
+ */
+export declare function getAxisAngle(q: Quat): AxisAngle;
+/**
+ * Gets the angular distance between two unit quaternions
+ *
+ * @param  a     Origin unit quaternion
+ * @param  b     Destination unit quaternion
+ * @return  Angle, in radians, between the two quaternions
+ */
+export declare function getAngle(a: Quat, b: Quat): number;
+/**
+ * Multiplies two quat's
+ *
+ * @param a the first operand
+ * @param b the second operand
+ */
+export declare function multiply(a: Quat, b: Quat): Quat;
+/**
+ * Rotates a quaternion by the given angle about the X axis
+ *
+ * @param a quat to rotate
+ * @param rad angle (in radians) to rotate
+ */
+export declare function rotateX(a: Quat, rad: number): Quat;
+/**
+ * Rotates a quaternion by the given angle about the Y axis
+ *
+ * @param a quat to rotate
+ * @param rad angle (in radians) to rotate
+ */
+export declare function rotateY(a: Quat, rad: number): Quat;
+/**
+ * Rotates a quaternion by the given angle about the Z axis
+ *
+ * @param a quat to rotate
+ * @param rad angle (in radians) to rotate
+ */
+export declare function rotateZ(a: Quat, rad: number): Quat;
+/**
+ * Calculates the W component of a quat from the X, Y, and Z components.
+ * Assumes that quaternion is 1 unit in length.
+ * Any existing W component will be ignored.
+ */
+export declare function calculateW(a: Quat): Quat;
+/**
+ * Calculate the exponential of a unit quaternion.
+ */
+export declare function exp(a: Quat): Quat;
+/**
+ * Calculate the natural logarithm of a unit quaternion.
+ */
+export declare function ln(a: Quat): Quat;
+/**
+ * Calculate the scalar power of a unit quaternion.
+ */
+export declare function pow(a: Quat, b: number): Quat;
+/**
+ * Performs a spherical linear interpolation between two quat
+ *
+ * @param a the first operand
+ * @param b the second operand
+ * @param t interpolation amount, in the range [0-1], between the two inputs
+ */
+export declare function slerp(a: Quat, b: Quat, t: number): Quat;
+/**
+ * Calculates the inverse of a quat
+ */
+export declare function invert(a: Quat): Quat;
+/**
+ * Calculates the conjugate of a quat
+ * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
+ */
+export declare function conjugate(a: Quat): Quat;
+/**
+ * Creates a quaternion from the given 3x3 rotation matrix.
+ *
+ * NOTE: The resultant quaternion is not normalized, so you should be sure
+ * to renormalize the quaternion yourself where necessary.
+ */
+export declare function fromMat3(m: Mat3): Quat;
+/**
+ * Creates a quaternion from the given euler angle x, y, z using the provided intrinsic order for the conversion.
+ *
+ * @param x Angle to rotate around X axis in degrees.
+ * @param y Angle to rotate around Y axis in degrees.
+ * @param z Angle to rotate around Z axis in degrees.
+ * @param order Intrinsic order for conversion, default is zyx.
+ * @function
+ */
+export declare function fromEuler(x: number, y: number, z: number, order?: Common.AngleOrder): number[];
+/**
+ * Adds two quat's
+ */
+export declare const add: (a: Quat, b: Quat) => Quat;
+/**
+ * Scales a quat by a scalar number
+ */
+export declare const scale: (a: Quat, b: number) => Quat;
+/**
+ * Calculates the dot product of two quat's
+ */
+export declare const dot: (a: Quat, b: Quat) => number;
+/**
+ * Performs a linear interpolation between two quat's
+ *
+ * @param a the first operand
+ * @param b the second operand
+ * @param t interpolation amount, in the range [0-1], between the two inputs
+ */
+export declare const lerp: (a: Quat, b: Quat, t: number) => Quat;
+/**
+ * Calculates the length of a quat
+ *
+ * @param a vector to calculate length of
+ * @returns length of a
+ */
+export declare const length: typeof vec4.length;
+/**
+ * Alias for {@link quat.length}
+ * @function
+ */
+export declare const len: typeof vec4.length;
+/**
+ * Calculates the squared length of a quat
+ *
+ * @param a vector to calculate squared length of
+ * @returns squared length of a
+ * @function
+ */
+export declare const squaredLength: typeof vec4.squaredLength;
+/**
+ * Alias for {@link quat.squaredLength}
+ * @function
+ */
+export declare const sqrLen: typeof vec4.squaredLength;
+/**
+ * Normalize a quat
+ *
+ * @param a quaternion to normalize
+ */
+export declare const normalize: typeof vec4.normalize;
+/**
+ * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+ */
+export declare const exactEquals: typeof vec4.exactEquals;
+/**
+ * Returns whether or not the quaternions point approximately to the same direction.
+ *
+ * Both quaternions are assumed to be unit length.
+ */
+export declare function equals(a: Quat, b: Quat): boolean;
+/**
+ * Sets a quaternion to represent the shortest rotation from one
+ * vector to another.
+ *
+ * Both vectors are assumed to be unit length.
+ *
+ * @param a the initial vector
+ * @param b the destination vector
+ */
+export declare const rotationTo: (a: Vec3, b: Vec3) => Quat;
+/**
+ * Performs a spherical linear interpolation with two control points
+ *
+ * @param a the first operand
+ * @param b the second operand
+ * @param c the third operand
+ * @param d the fourth operand
+ * @param t interpolation amount, in the range [0-1], between the two inputs
+ */
+export declare function sqlerp(a: Quat, b: Quat, c: Quat, d: Quat, t: number): Quat;
+/**
+ * Sets the specified quaternion with values corresponding to the given
+ * axes. Each axis is a vec3 and is expected to be unit length and
+ * perpendicular to all other specified axes.
+ *
+ * @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
+ */
+export declare function setAxes(view: Vec3, right: Vec3, up: Vec3): Quat;
+export {};