linearly 0.0.0

package/lib/mat4.d.ts

@@ -0,0 +1,310 @@
+import { Quat } from './quat';
+import { Vec3 } from './vec3';
+export type Mat4 = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
+ */
+/**
+ * The identity matrix of mat4
+ */
+export declare const identity: Mat4;
+/**
+ * Transpose the values of a mat4
+ */
+export declare function transpose(a: Mat4): Mat4;
+/**
+ * Inverts a mat4
+ */
+export declare function invert(a: Mat4): Mat4 | null;
+/**
+ * Calculates the adjugate of a mat4
+ */
+export declare function adjoint(a: Mat4): Mat4;
+/**
+ * Calculates the determinant of a mat4
+ */
+export declare function determinant(a: Mat4): number;
+/**
+ * Multiplies two mat4's
+ */
+export declare function multiply(a: Mat4, b: Mat4): Mat4;
+/**
+ * Translate a mat4 by the given vector
+ *
+ * @param a the matrix to translate
+ * @param v vector to translate by
+ */
+export declare function translate(a: Mat4, v: Vec3): Mat4;
+/**
+ * Scales the mat4 by the dimensions in the given vec3 not using vectorization
+ **/
+export declare function scale(a: Mat4, v: Vec3): Mat4;
+/**
+ * Rotates a mat4 by the given angle around the given axis
+ */
+export declare function rotate(a: Mat4, rad: number, axis: Vec3): Mat4 | null;
+/**
+ * Rotates a matrix by the given angle around the X axis
+ */
+export declare function rotateX(a: Mat4, rad: number): Mat4;
+/**
+ * Rotates a matrix by the given angle around the Y axis
+ */
+export declare function rotateY(a: Mat4, rad: number): Mat4;
+/**
+ * Rotates a matrix by the given angle around the Z axis
+ */
+export declare function rotateZ(a: Mat4, rad: number): Mat4;
+/**
+ * Creates a matrix from a vector translation
+ */
+export declare function fromTranslation(v: Vec3): Mat4;
+/**
+ * Creates a matrix from a vector scaling
+ */
+export declare function fromScaling(v: Vec3): Mat4;
+/**
+ * Creates a matrix from a given angle around a given axis
+ */
+export declare function fromRotation(rad: number, axis: Vec3): Mat4 | null;
+/**
+ * Creates a matrix from the given angle around the X axis
+ */
+export declare function fromXRotation(rad: number): Mat4;
+/**
+ * Creates a matrix from the given angle around the Y axis
+ */
+export declare function fromYRotation(rad: number): Mat4;
+/**
+ * Creates a matrix from the given angle around the Z axis
+ */
+export declare function fromZRotation(rad: number): Mat4;
+/**
+ * Creates a matrix from a quaternion rotation and vector translation
+ */
+export declare function fromRotationTranslation(q: Quat, v: Vec3): Mat4;
+/**
+ * Returns the translation vector component of a transformation
+ *  matrix. If a matrix is built with fromRotationTranslation,
+ *  the returned vector will be the same as the translation vector
+ *  originally supplied.
+ */
+export declare function getTranslation(mat: Mat4): Vec3;
+/**
+ * Returns the scaling factor component of a transformation
+ *  matrix. If a matrix is built with fromRotationTranslationScale
+ *  with a normalized Quaternion paramter, the returned vector will be
+ *  the same as the scaling vector
+ *  originally supplied.
+ */
+export declare function getScaling(mat: Mat4): Vec3;
+/**
+ * Returns a quaternion representing the rotational component
+ *  of a transformation matrix. If a matrix is built with
+ *  fromRotationTranslation, the returned quaternion will be the
+ *  same as the quaternion originally supplied.
+ */
+export declare function getRotation(mat: Mat4): Quat;
+interface DecomposedTRS {
+    rot: Quat;
+    trans: Vec3;
+    scale: Vec3;
+}
+/**
+ * Decomposes a transformation matrix into its rotation, translation
+ * and scale components. Returns only the rotation component
+ *
+ * @param  mat Matrix to be decomposed (input)
+ */
+export declare function decompose(mat: Mat4): DecomposedTRS;
+/**
+ * Creates a matrix from a quaternion rotation, vector translation and vector scale
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.translate(dest, vec);
+ *     const quatMat = mat4.create();
+ *     quat4.toMat4(quat, quatMat);
+ *     mat4.multiply(dest, quatMat);
+ *     mat4.scale(dest, scale)
+ *
+ * @param rot Rotation quaternion
+ * @param trans Translation vector
+ * @param scale Scaling vector
+ */
+export declare function fromRotationTranslationScale(rot: Quat, trans: Vec3, scale: Vec3): Mat4;
+/**
+ * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.translate(dest, vec);
+ *     mat4.translate(dest, origin);
+ *     const quatMat = mat4.create();
+ *     quat4.toMat4(quat, quatMat);
+ *     mat4.multiply(dest, quatMat);
+ *     mat4.scale(dest, scale)
+ *     mat4.translate(dest, negativeOrigin);
+ *
+ * @param rot Rotation quaternion
+ * @param trans Translation vector
+ * @param scale Scaling vector
+ * @param origin The origin vector around which to scale and rotate
+ */
+export declare function fromRotationTranslationScaleOrigin(rot: Quat, trans: Vec3, scale: Vec3, origin: Vec3): number[];
+/**
+ * Calculates a 4x4 matrix from the given quaternion
+ *
+ * @param q Quaternion to create matrix from
+ */
+export declare function fromQuat(q: Quat): Mat4;
+/**
+ * Generates a frustum matrix with the given bounds
+ *
+ * @param left Left bound of the frustum
+ * @param right Right bound of the frustum
+ * @param bottom Bottom bound of the frustum
+ * @param top Top bound of the frustum
+ * @param near Near bound of the frustum
+ * @param far Far bound of the frustum
+ */
+export declare function frustum(left: number, right: number, bottom: number, top: number, near: number, far: number): number[];
+/**
+ * Generates a perspective projection matrix with the given bounds.
+ * The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],
+ * which matches WebGL/OpenGL's clip volume.
+ * Passing null/undefined/no value for far will generate infinite projection matrix.
+ *
+ * @param fovy Vertical field of view in radians
+ * @param aspect Aspect ratio. typically viewport width/height
+ * @param near Near bound of the frustum
+ * @param far Far bound of the frustum, can be null or Infinity
+ */
+export declare function perspectiveNO(fovy: number, aspect: number, near: number, far: number): Mat4;
+/**
+ * Alias for {@link mat4.perspectiveNO}
+ * @function
+ */
+export declare const perspective: typeof perspectiveNO;
+/**
+ * Generates a perspective projection matrix suitable for WebGPU with the given bounds.
+ * The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1],
+ * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.
+ * Passing null/undefined/no value for far will generate infinite projection matrix.
+ *
+ * @param fovy Vertical field of view in radians
+ * @param aspect Aspect ratio. typically viewport width/height
+ * @param near Near bound of the frustum
+ * @param far Far bound of the frustum, can be null or Infinity
+ */
+export declare function perspectiveZO(fovy: number, aspect: number, near: number, far: number | null): Mat4;
+interface FovDegrees {
+    upDegrees: number;
+    downDegrees: number;
+    leftDegrees: number;
+    rightDegrees: number;
+}
+/**
+ * Generates a perspective projection matrix with the given field of view.
+ * This is primarily useful for generating projection matrices to be used
+ * with the still experiemental WebVR API.
+ *
+ * @param fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees
+ * @param near Near bound of the frustum
+ * @param far Far bound of the frustum
+ */
+export declare function perspectiveFromFieldOfView(fov: FovDegrees, near: number, far: number): Mat4;
+/**
+ * Generates a orthogonal projection matrix with the given bounds.
+ * The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],
+ * which matches WebGL/OpenGL's clip volume.
+ *
+ * @param left Left bound of the frustum
+ * @param right Right bound of the frustum
+ * @param bottom Bottom bound of the frustum
+ * @param top Top bound of the frustum
+ * @param near Near bound of the frustum
+ * @param far Far bound of the frustum
+ */
+export declare function orthoNO(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+/**
+ * Alias for {@link mat4.orthoNO}
+ * @function
+ */
+export declare const ortho: typeof orthoNO;
+/**
+ * Generates a orthogonal projection matrix with the given bounds.
+ * The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1],
+ * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.
+ *
+ * @param left Left bound of the frustum
+ * @param right Right bound of the frustum
+ * @param bottom Bottom bound of the frustum
+ * @param top Top bound of the frustum
+ * @param near Near bound of the frustum
+ * @param far Far bound of the frustum
+ */
+export declare function orthoZO(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+/**
+ * Generates a look-at matrix with the given eye position, focal point, and up axis.
+ * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.
+ *
+ * @param eye Position of the viewer
+ * @param center Point the viewer is looking at
+ * @param up vec3 pointing up
+ */
+export declare function lookAt(eye: Vec3, center: Vec3, up: Vec3): Mat4;
+/**
+ * Generates a matrix that makes something look at something else.
+ *
+ * @param eye Position of the viewer
+ * @param center Point the viewer is looking at
+ * @param up vec3 pointing up
+ */
+export declare function targetTo(eye: Vec3, target: Vec3, up: Vec3): Mat4;
+/**
+ * Returns Frobenius norm of a mat4
+ */
+export declare function frob(a: Mat4): number;
+/**
+ * Adds two mat4's
+ */
+export declare function add(a: Mat4, b: Mat4): number[];
+/**
+ * Subtracts matrix b from matrix a
+ */
+export declare function subtract(a: Mat4, b: Mat4): Mat4;
+/**
+ * Multiply each element of the matrix by a scalar.
+ */
+export declare function multiplyScalar(a: Mat4, s: number): Mat4;
+/**
+ * Adds two mat4's after multiplying each element of the second operand by a scalar value.
+ */
+export declare function multiplyScalarAndAdd(a: Mat4, b: Mat4, scale: number): Mat4;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export declare function exactEquals(a: Mat4, b: Mat4): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export declare function equals(a: Mat4, b: Mat4): boolean;
+export {};