gl-mat4

What is gl-mat4?

The gl-mat4 npm package is a utility library for performing operations on 4x4 matrices, which are commonly used in WebGL and other graphics programming contexts. It provides a variety of functions for creating, manipulating, and transforming 4x4 matrices.

What are gl-mat4's main functionalities?

Matrix Creation

This feature allows you to create a new 4x4 identity matrix. An identity matrix is a special kind of matrix that doesn't change any vector when we multiply that vector by this matrix.

const mat4 = require('gl-mat4');
const identityMatrix = mat4.create();

Matrix Multiplication

This feature allows you to multiply two 4x4 matrices. Matrix multiplication is a fundamental operation in graphics programming for combining multiple transformations.

const mat4 = require('gl-mat4');
const a = mat4.create();
const b = mat4.create();
const result = mat4.multiply(mat4.create(), a, b);

Matrix Translation

This feature allows you to apply a translation transformation to a 4x4 matrix. Translation is used to move objects in 3D space.

const mat4 = require('gl-mat4');
const out = mat4.create();
const translation = [1, 2, 3];
mat4.translate(out, out, translation);

Matrix Rotation

This feature allows you to apply a rotation transformation to a 4x4 matrix. Rotation is used to rotate objects around a specified axis.

const mat4 = require('gl-mat4');
const out = mat4.create();
const rad = Math.PI / 4;
const axis = [0, 0, 1];
mat4.rotate(out, out, rad, axis);

Matrix Scaling

This feature allows you to apply a scaling transformation to a 4x4 matrix. Scaling is used to resize objects in 3D space.

const mat4 = require('gl-mat4');
const out = mat4.create();
const scale = [2, 2, 2];
mat4.scale(out, out, scale);

Other packages similar to gl-mat4

gl-matrix

gl-matrix is a high-performance matrix and vector library for WebGL. It provides similar functionalities to gl-mat4 but also includes support for other types of matrices and vectors, such as 2x2, 3x3, and 4x4 matrices, as well as 2D, 3D, and 4D vectors. It is more comprehensive and widely used in the WebGL community.

three.js

three.js is a popular 3D library that abstracts WebGL and provides a higher-level API for creating and manipulating 3D graphics. While it includes matrix and vector operations similar to gl-mat4, it also offers a full suite of tools for rendering, animation, and interaction, making it a more complete solution for 3D graphics development.

mathjs

mathjs is a comprehensive math library for JavaScript that includes support for matrices and vectors, among many other mathematical operations. While it is not specifically designed for WebGL, it provides a wide range of mathematical tools that can be useful in graphics programming.

README

gl-mat4

Part of a fork of @toji's gl-matrix split into smaller pieces: this package contains glMatrix.mat4.

Usage

mat4 = require('gl-mat4')

Will load all of the module's functionality and expose it on a single object. Note that any of the methods may also be required directly from their files.

For example, the following are equivalent:

var scale = require('gl-mat4').scale
var scale = require('gl-mat4/scale')

API

• adjoint()
• clone()
• copy()
• create()
• determinant()
• fromQuat()
• fromRotation()
• fromRotationTranslation()
• fromScaling()
• fromTranslation()
• fromXRotation()
• fromYRotation()
• fromZRotation()
• frustum()
• identity()
• invert()
• lookAt()
• multiply()
• ortho()
• perspective()
• perspectiveFromFieldOfView()
• rotate()
• rotateX()
• rotateY()
• rotateZ()
• scale()
• str()
• translate()
• transpose()

adjoint(out:mat4, a:mat4)

Calculates the adjugate of a mat4

clone(a:mat4)

Creates a new mat4 initialized with values from an existing matrix

copy(out:mat4, a:mat4)

Copy the values from one mat4 to another

create()

Creates a new identity mat4

determinant(a:mat4)

Calculates the determinant of a mat4

fromQuat(out:mat4, q:quat4)

Creates a matrix from a quaternion rotation.

fromRotation(out:mat4, rad:number, axis:vec3)

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);

fromRotationTranslation(out:mat4, q:quat4, v:vec3)

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);
  var quatMat = mat4.create();
  quat4.toMat4(quat, quatMat);
  mat4.multiply(dest, quatMat);

fromScaling(out:mat4, v:vec3)

Creates a matrix from a vector scaling. This is equivalent to (but much faster than):

  mat4.identity(dest);
  mat4.translate(dest, dest, vec);

fromTranslation(out:mat4, v:vec3)

Creates a matrix from a vector translation. This is equivalent to (but much faster than):

  mat4.identity(dest);
  mat4.translate(dest, dest, vec);

fromTranslation(out:mat4, v:vec3)

Creates a matrix from a vector translation This is equivalent to (but much faster than):

  mat4.identity(dest);
  mat4.translate(dest, dest, vec);

fromXRotation(out:mat4, rad:Number)

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)

fromYRotation(out:mat4, rad:Number)

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)

fromZRotation(out:mat4, rad:Number)

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)

frustum(out:mat4, left:Number, right:Number, bottom:Number, top:Number, near:Number, far:Number)

Generates a frustum matrix with the given bounds

identity(out:mat4)

Set a mat4 to the identity matrix

invert(out:mat4, a:mat4)

Inverts a mat4

lookAt(out:mat4, eye:vec3, center:vec3, up:vec3)

Generates a look-at matrix with the given eye position, focal point, and up axis

multiply(out:mat4, a:mat4, b:mat4)

Multiplies two mat4's

ortho(out:mat4, left:number, right:number, bottom:number, top:number, near:number, far:number)

Generates a orthogonal projection matrix with the given bounds

perspective(out:mat4, fovy:number, aspect:number, near:number, far:number)

Generates a perspective projection matrix with the given bounds

perspectiveFromFieldOfView(out:mat4, fov:object, near:number, far:number)

Generates a perspective projection matrix with the given field of view.

rotate(out:mat4, a:mat4, rad:Number, axis:vec3)

Rotates a mat4 by the given angle

rotateX(out:mat4, a:mat4, rad:Number)

Rotates a matrix by the given angle around the X axis

rotateY(out:mat4, a:mat4, rad:Number)

Rotates a matrix by the given angle around the Y axis

rotateZ(out:mat4, a:mat4, rad:Number)

Rotates a matrix by the given angle around the Z axis

scale(out:mat4, a:mat4, v:vec3)

Scales the mat4 by the dimensions in the given vec3

str(mat:mat4)

Returns a string representation of a mat4

translate(out:mat4, a:mat4, v:vec3)

Translate a mat4 by the given vector

transpose(out:mat4, a:mat4)

Transpose the values of a mat4

License

zlib. See LICENSE.md for details.