linearly 0.3.0 → 0.4.1

package/lib/esm/quat.d.ts

@@ -0,0 +1,220 @@
+import * as Common from './common';
+import type { Mat3 } from './mat3';
+import type { Vec3 } from './vec3';
+import * as vec4 from './vec4';
+/**
+ * Quaternion in the format XYZW
+ * @module quat
+ */
+export type Quat = readonly [number, number, number, number];
+export declare function of(x: number, y: number, z: number, w: number): 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 {};
+//# sourceMappingURL=quat.d.ts.map

package/lib/esm/quat.d.ts.map

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