@math.gl/core 3.6.3 → 4.0.0-alpha.2

package/dist/gl-matrix/mat4.d.ts

@@ -0,0 +1,577 @@
+/**
+ * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
+ * @module mat4
+ */
+/**
+ * Creates a new identity mat4
+ *
+ * @returns a new 4x4 matrix
+ */
+export function create(): any[] | Float32Array;
+/**
+ * Creates a new mat4 initialized with values from an existing matrix
+ *
+ * @param {ReadonlyMat4} a matrix to clone
+ * @returns {mat4} a new 4x4 matrix
+ */
+export function clone(a: ReadonlyMat4): mat4;
+/**
+ * Copy the values from one mat4 to another
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {mat4} out
+ */
+export function copy(out: mat4, a: ReadonlyMat4): mat4;
+/**
+ * Create a new mat4 with the given values
+ *
+ * @param {Number} m00 Component in column 0, row 0 position (index 0)
+ * @param {Number} m01 Component in column 0, row 1 position (index 1)
+ * @param {Number} m02 Component in column 0, row 2 position (index 2)
+ * @param {Number} m03 Component in column 0, row 3 position (index 3)
+ * @param {Number} m10 Component in column 1, row 0 position (index 4)
+ * @param {Number} m11 Component in column 1, row 1 position (index 5)
+ * @param {Number} m12 Component in column 1, row 2 position (index 6)
+ * @param {Number} m13 Component in column 1, row 3 position (index 7)
+ * @param {Number} m20 Component in column 2, row 0 position (index 8)
+ * @param {Number} m21 Component in column 2, row 1 position (index 9)
+ * @param {Number} m22 Component in column 2, row 2 position (index 10)
+ * @param {Number} m23 Component in column 2, row 3 position (index 11)
+ * @param {Number} m30 Component in column 3, row 0 position (index 12)
+ * @param {Number} m31 Component in column 3, row 1 position (index 13)
+ * @param {Number} m32 Component in column 3, row 2 position (index 14)
+ * @param {Number} m33 Component in column 3, row 3 position (index 15)
+ * @returns {mat4} A new mat4
+ */
+export function fromValues(m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): mat4;
+/**
+ * Set the components of a mat4 to the given values
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {Number} m00 Component in column 0, row 0 position (index 0)
+ * @param {Number} m01 Component in column 0, row 1 position (index 1)
+ * @param {Number} m02 Component in column 0, row 2 position (index 2)
+ * @param {Number} m03 Component in column 0, row 3 position (index 3)
+ * @param {Number} m10 Component in column 1, row 0 position (index 4)
+ * @param {Number} m11 Component in column 1, row 1 position (index 5)
+ * @param {Number} m12 Component in column 1, row 2 position (index 6)
+ * @param {Number} m13 Component in column 1, row 3 position (index 7)
+ * @param {Number} m20 Component in column 2, row 0 position (index 8)
+ * @param {Number} m21 Component in column 2, row 1 position (index 9)
+ * @param {Number} m22 Component in column 2, row 2 position (index 10)
+ * @param {Number} m23 Component in column 2, row 3 position (index 11)
+ * @param {Number} m30 Component in column 3, row 0 position (index 12)
+ * @param {Number} m31 Component in column 3, row 1 position (index 13)
+ * @param {Number} m32 Component in column 3, row 2 position (index 14)
+ * @param {Number} m33 Component in column 3, row 3 position (index 15)
+ * @returns {mat4} out
+ */
+export function set(out: mat4, m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): mat4;
+/**
+ * Set a mat4 to the identity matrix
+ *
+ * @param {mat4} out the receiving matrix
+ * @returns {mat4} out
+ */
+export function identity(out: mat4): mat4;
+/**
+ * Transpose the values of a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {mat4} out
+ */
+export function transpose(out: mat4, a: ReadonlyMat4): mat4;
+/**
+ * Inverts a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {mat4} out
+ */
+export function invert(out: mat4, a: ReadonlyMat4): mat4;
+/**
+ * Calculates the adjugate of a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {mat4} out
+ */
+export function adjoint(out: mat4, a: ReadonlyMat4): mat4;
+/**
+ * Calculates the determinant of a mat4
+ *
+ * @param {ReadonlyMat4} a the source matrix
+ * @returns {Number} determinant of a
+ */
+export function determinant(a: ReadonlyMat4): number;
+/**
+ * Multiplies two mat4s
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @returns {mat4} out
+ */
+export function multiply(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4;
+/**
+ * Translate a mat4 by the given vector
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to translate
+ * @param {ReadonlyVec3} v vector to translate by
+ * @returns {mat4} out
+ */
+export function translate(out: mat4, a: ReadonlyMat4, v: ReadonlyVec3): mat4;
+/**
+ * Scales the mat4 by the dimensions in the given vec3 not using vectorization
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to scale
+ * @param {ReadonlyVec3} v the vec3 to scale the matrix by
+ * @returns {mat4} out
+ **/
+export function scale(out: mat4, a: ReadonlyMat4, v: ReadonlyVec3): mat4;
+/**
+ * Rotates a mat4 by the given angle around the given axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @param {ReadonlyVec3} axis the axis to rotate around
+ * @returns {mat4} out
+ */
+export function rotate(out: mat4, a: ReadonlyMat4, rad: number, axis: ReadonlyVec3): mat4;
+/**
+ * Rotates a matrix by the given angle around the X axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+export function rotateX(out: mat4, a: ReadonlyMat4, rad: number): mat4;
+/**
+ * Rotates a matrix by the given angle around the Y axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+export function rotateY(out: mat4, a: ReadonlyMat4, rad: number): mat4;
+/**
+ * Rotates a matrix by the given angle around the Z axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+export function rotateZ(out: mat4, a: ReadonlyMat4, rad: number): mat4;
+/**
+ * Creates a matrix from a vector translation
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.translate(dest, dest, vec);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {ReadonlyVec3} v Translation vector
+ * @returns {mat4} out
+ */
+export function fromTranslation(out: mat4, v: ReadonlyVec3): mat4;
+/**
+ * Creates a matrix from a vector scaling
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.scale(dest, dest, vec);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {ReadonlyVec3} v Scaling vector
+ * @returns {mat4} out
+ */
+export function fromScaling(out: mat4, v: ReadonlyVec3): mat4;
+/**
+ * Creates a matrix from a given angle around a given axis
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.rotate(dest, dest, rad, axis);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {Number} rad the angle to rotate the matrix by
+ * @param {ReadonlyVec3} axis the axis to rotate around
+ * @returns {mat4} out
+ */
+export function fromRotation(out: mat4, rad: number, axis: ReadonlyVec3): mat4;
+/**
+ * Creates a matrix from the given angle around the X axis
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.rotateX(dest, dest, rad);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+export function fromXRotation(out: mat4, rad: number): mat4;
+/**
+ * Creates a matrix from the given angle around the Y axis
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.rotateY(dest, dest, rad);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+export function fromYRotation(out: mat4, rad: number): mat4;
+/**
+ * Creates a matrix from the given angle around the Z axis
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.rotateZ(dest, dest, rad);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+export function fromZRotation(out: mat4, rad: number): mat4;
+/**
+ * Creates a matrix from a quaternion rotation and vector translation
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.translate(dest, vec);
+ *     let quatMat = mat4.create();
+ *     quat4.toMat4(quat, quatMat);
+ *     mat4.multiply(dest, quatMat);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat4} q Rotation quaternion
+ * @param {ReadonlyVec3} v Translation vector
+ * @returns {mat4} out
+ */
+export function fromRotationTranslation(out: mat4, q: quat4, v: ReadonlyVec3): mat4;
+/**
+ * Creates a new mat4 from a dual quat.
+ *
+ * @param {mat4} out Matrix
+ * @param {ReadonlyQuat2} a Dual Quaternion
+ * @returns {mat4} mat4 receiving operation result
+ */
+export function fromQuat2(out: mat4, a: ReadonlyQuat2): 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.
+ * @param  {vec3} out Vector to receive translation component
+ * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
+ * @return {vec3} out
+ */
+export function getTranslation(out: vec3, mat: ReadonlyMat4): 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.
+ * @param  {vec3} out Vector to receive scaling factor component
+ * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
+ * @return {vec3} out
+ */
+export function getScaling(out: vec3, mat: ReadonlyMat4): 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.
+ * @param {quat} out Quaternion to receive the rotation component
+ * @param {ReadonlyMat4} mat Matrix to be decomposed (input)
+ * @return {quat} out
+ */
+export function getRotation(out: quat, mat: ReadonlyMat4): quat;
+/**
+ * Decomposes a transformation matrix into its rotation, translation
+ * and scale components. Returns only the rotation component
+ * @param  {quat} out_r Quaternion to receive the rotation component
+ * @param  {vec3} out_t Vector to receive the translation vector
+ * @param  {vec3} out_s Vector to receive the scaling factor
+ * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
+ * @returns {quat} out_r
+ */
+export function decompose(out_r: quat, out_t: vec3, out_s: vec3, mat: ReadonlyMat4): quat;
+/**
+ * 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);
+ *     let quatMat = mat4.create();
+ *     quat4.toMat4(quat, quatMat);
+ *     mat4.multiply(dest, quatMat);
+ *     mat4.scale(dest, scale)
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat4} q Rotation quaternion
+ * @param {ReadonlyVec3} v Translation vector
+ * @param {ReadonlyVec3} s Scaling vector
+ * @returns {mat4} out
+ */
+export function fromRotationTranslationScale(out: mat4, q: quat4, v: ReadonlyVec3, s: ReadonlyVec3): 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);
+ *     let quatMat = mat4.create();
+ *     quat4.toMat4(quat, quatMat);
+ *     mat4.multiply(dest, quatMat);
+ *     mat4.scale(dest, scale)
+ *     mat4.translate(dest, negativeOrigin);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat4} q Rotation quaternion
+ * @param {ReadonlyVec3} v Translation vector
+ * @param {ReadonlyVec3} s Scaling vector
+ * @param {ReadonlyVec3} o The origin vector around which to scale and rotate
+ * @returns {mat4} out
+ */
+export function fromRotationTranslationScaleOrigin(out: mat4, q: quat4, v: ReadonlyVec3, s: ReadonlyVec3, o: ReadonlyVec3): mat4;
+/**
+ * Calculates a 4x4 matrix from the given quaternion
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {ReadonlyQuat} q Quaternion to create matrix from
+ *
+ * @returns {mat4} out
+ */
+export function fromQuat(out: mat4, q: ReadonlyQuat): mat4;
+/**
+ * Generates a frustum matrix with the given bounds
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {Number} left Left bound of the frustum
+ * @param {Number} right Right bound of the frustum
+ * @param {Number} bottom Bottom bound of the frustum
+ * @param {Number} top Top bound of the frustum
+ * @param {Number} near Near bound of the frustum
+ * @param {Number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+export function frustum(out: mat4, left: number, right: number, bottom: number, top: number, near: number, far: number): mat4;
+/**
+ * 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {number} fovy Vertical field of view in radians
+ * @param {number} aspect Aspect ratio. typically viewport width/height
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum, can be null or Infinity
+ * @returns {mat4} out
+ */
+export function perspectiveNO(out: mat4, fovy: number, aspect: number, near: number, far: number): mat4;
+/**
+ * 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {number} fovy Vertical field of view in radians
+ * @param {number} aspect Aspect ratio. typically viewport width/height
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum, can be null or Infinity
+ * @returns {mat4} out
+ */
+export function perspectiveZO(out: mat4, fovy: number, aspect: number, near: number, far: number): mat4;
+/**
+ * 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+export function perspectiveFromFieldOfView(out: mat4, fov: any, 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {number} left Left bound of the frustum
+ * @param {number} right Right bound of the frustum
+ * @param {number} bottom Bottom bound of the frustum
+ * @param {number} top Top bound of the frustum
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+export function orthoNO(out: mat4, left: number, right: number, bottom: number, top: number, 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 [0, 1],
+ * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {number} left Left bound of the frustum
+ * @param {number} right Right bound of the frustum
+ * @param {number} bottom Bottom bound of the frustum
+ * @param {number} top Top bound of the frustum
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+export function orthoZO(out: mat4, 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {ReadonlyVec3} eye Position of the viewer
+ * @param {ReadonlyVec3} center Point the viewer is looking at
+ * @param {ReadonlyVec3} up vec3 pointing up
+ * @returns {mat4} out
+ */
+export function lookAt(out: mat4, eye: ReadonlyVec3, center: ReadonlyVec3, up: ReadonlyVec3): mat4;
+/**
+ * Generates a matrix that makes something look at something else.
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {ReadonlyVec3} eye Position of the viewer
+ * @param {ReadonlyVec3} center Point the viewer is looking at
+ * @param {ReadonlyVec3} up vec3 pointing up
+ * @returns {mat4} out
+ */
+export function targetTo(out: mat4, eye: ReadonlyVec3, target: any, up: ReadonlyVec3): mat4;
+/**
+ * Returns a string representation of a mat4
+ *
+ * @param {ReadonlyMat4} a matrix to represent as a string
+ * @returns {String} string representation of the matrix
+ */
+export function str(a: ReadonlyMat4): string;
+/**
+ * Returns Frobenius norm of a mat4
+ *
+ * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of
+ * @returns {Number} Frobenius norm
+ */
+export function frob(a: ReadonlyMat4): number;
+/**
+ * Adds two mat4's
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @returns {mat4} out
+ */
+export function add(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4;
+/**
+ * Subtracts matrix b from matrix a
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @returns {mat4} out
+ */
+export function subtract(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4;
+/**
+ * Multiply each element of the matrix by a scalar.
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to scale
+ * @param {Number} b amount to scale the matrix's elements by
+ * @returns {mat4} out
+ */
+export function multiplyScalar(out: mat4, a: ReadonlyMat4, b: number): mat4;
+/**
+ * Adds two mat4's after multiplying each element of the second operand by a scalar value.
+ *
+ * @param {mat4} out the receiving vector
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @param {Number} scale the amount to scale b's elements by before adding
+ * @returns {mat4} out
+ */
+export function multiplyScalarAndAdd(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4, scale: number): mat4;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ *
+ * @param {ReadonlyMat4} a The first matrix.
+ * @param {ReadonlyMat4} b The second matrix.
+ * @returns {Boolean} True if the matrices are equal, false otherwise.
+ */
+export function exactEquals(a: ReadonlyMat4, b: ReadonlyMat4): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ *
+ * @param {ReadonlyMat4} a The first matrix.
+ * @param {ReadonlyMat4} b The second matrix.
+ * @returns {Boolean} True if the matrices are equal, false otherwise.
+ */
+export function equals(a: ReadonlyMat4, b: ReadonlyMat4): boolean;
+/**
+ * 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {number} fovy Vertical field of view in radians
+ * @param {number} aspect Aspect ratio. typically viewport width/height
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum, can be null or Infinity
+ * @returns {mat4} out
+ */
+export function perspective(out: mat4, fovy: number, aspect: number, 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 {mat4} out mat4 frustum matrix will be written into
+ * @param {number} left Left bound of the frustum
+ * @param {number} right Right bound of the frustum
+ * @param {number} bottom Bottom bound of the frustum
+ * @param {number} top Top bound of the frustum
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+export function ortho(out: mat4, left: number, right: number, bottom: number, top: number, near: number, far: number): mat4;
+/**
+ * Multiplies two mat4s
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @returns {mat4} out
+ */
+export function mul(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4;
+/**
+ * Subtracts matrix b from matrix a
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the first operand
+ * @param {ReadonlyMat4} b the second operand
+ * @returns {mat4} out
+ */
+export function sub(out: mat4, a: ReadonlyMat4, b: ReadonlyMat4): mat4;
+//# sourceMappingURL=mat4.d.ts.map

package/dist/gl-matrix/mat4.d.ts.map

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