glmaths

Linear algebra functions for working with WebGL in TypeScript, aimed to be looking similar to GLSL code. Inspired by gl-matrix.

How to install

You can take dist/glmaths.min.js, or install with npm:

npm install glmaths

There are also dist/cjs/ and dist/esm/ builds for different import formats.

Usage Example

// from glmaths[.min].js:
const { vec3, vec4, mat4, quat } = glmaths
// from npm:
import { vec3, vec4, mat4, quat } from 'glmaths'

const vertex = vec3(2, 1, 0)
vertex.rotateX(Math.PI / 3, vec3(0.5))

const proj = mat4.perspective(Math.PI / 2, 16 / 9, 0.001, 1000)
const view = mat4.lookAt(vec3(0, 0, -10), vec3(0), vec3(0, 0, 1))
const ndc = vertex.transformMat4(proj.mult(view))

// All types extend Float32Array, so you can pass them to webgl
gl.uniformMatrix4fv(u_proj, false, proj)

Swizzles!

.xyzw, .rgba, .stpq, .uv swizzles are supported on vec2, vec3, vec4.

0 and 1 on not first symbol are also supported, f.ex: a.x0z, b.rgb1, c.uv01.

Vector packing

You can pass vector in a vector, just like in GLSL: vec4(vec2(0, 1), 2, 3)

Operator Overloading!

If you code in TypeScript, you can opt for a fork of TypeScript to enable operator overloading in code! glmaths implements functions needed to overload these operators: + - * / % == ===

mat4.perspective(Math.PI / 2) * vec4(vec2(1, 2) / 4.0 + 2.0, 1.0, 1.0)

With this done, it totally looks like GLSL! :D

out argument

Like gl-matrix, all functions have out argument, but it is located at the end as an optional argument.

const a = vec3(0, 1, 2)
const b = vec3(2, 3, 4)
const c = vec3()
a.plus(b, /* out = */ c)

By default, default value of out is always a new clone of a structure. Not using out will create overhead to GC leading to worse performance, so for production pre-allocating structures and passing them in out argument is recommended.

You can also opt for modifying existing structure when using instance methods, by setting glmaths.ALWAYS_COPY = false. This way every operation, by default, will update its own structure. This might bring confusion, when saving structures in variables, as it modifies itself, hence why this is not the default behaviour. Example below:

glmaths.ALWAYS_COPY = false
const a = vec3(0, 1, 2)
const b = a.plus(5)
// a.x === 5

Docs

• EPSILON = 0.000001 — used in a.equals(b) functions
• RANDOM = Math.random — used in .random() functions
• ANGLE_ORDER = 'zyx' — used in Quat.fromEuler
• ALWAYS_COPY = false
• LEFT_HANDED = false — set to true for left handed geometry, used in mat4

mat2

• clone(): mat2
• transpose(out?: mat2): mat2
• invert(out?: mat2): mat2 | null
• adjoint(out?: mat2): mat2
• determinant(): number
• rotate(rad: number, out?: mat2): mat2
• scale(v: vec2, out?: mat2): mat2
• static fromRotation(rad: number, out?: mat2): mat2
• static fromScaling(v: vec2, out?: mat2): mat2
• toString(): string
• str → toString
• frob(): number
• LDU(L?: mat2, D?: mat2, U?: mat2): mat2[]
• plus(b: mat2, out?: mat2): mat2
• add → plus
• minus(b: mat2, out?: mat2): mat2
• sub → minus
• subtract → minus
• multiply(b: mat2 | vec2, out?: mat2): mat2 | vec2
• mul → multiply
• mult → multiply
• times → multiply
• exactEquals(b: mat2): boolean
• equals(b: mat2): boolean
• scaleScalar(b: number, out?: mat2): mat2
• multiplyScalar → scaleScalar

mat2x3

• invert(out?: mat2x3): mat2x3 | null
• determinant(): number
• rotate(rad: number, out?: mat2x3): mat2x3
• scale(v: vec2, out?: mat2x3): mat2x3
• translate(v: vec2, out?: mat2x3): mat2x3
• static fromRotation(rad: number, out?: mat2x3): mat2x3
• static fromScaling(v: vec2, out?: mat2x3): mat2x3
• static fromTranslation(v: vec2, out?: mat2x3): mat2x3
• toString(): string
• str → toString
• frob(): number
• plus(b: mat2x3, out?: mat2x3): mat2x3
• add → plus
• minus(b: mat2x3, out?: mat2x3): mat2x3
• sub → minus
• subtract → minus
• multiply(b: vec2 | mat2x3, out?: mat2x3): vec2 | mat2x3
• mul → multiply
• mult → multiply
• times → multiply
• equals(b: mat2x3): boolean
• exactEquals(b: mat2x3): boolean
• scaleScalar(b: number, out?: mat2x3): mat2x3
• multiplyScalar → scaleScalar
• clone(): mat2x3

mat3

• clone(): mat3
• transpose(out?: mat3): mat3
• invert(out?: mat3): mat3 | null
• adjoint(out?: mat3): mat3
• determinant(): number
• multiply(b: vec2 | vec3 | mat3, out?: mat3): vec2 | vec3 | mat3
• mul → multiply
• mult → multiply
• times → multiply
• translate(v: vec2, out?: mat3): mat3
• rotate(rad: number, out?: mat3): mat3
• scale(v: vec2, out?: mat3): mat3
• static fromTranslation(v: vec2, out?: mat3): mat3
• static fromRotation(rad: number, out?: mat3): mat3
• static fromScaling(v: vec2, out?: mat3): mat3
• static fromMat2x3(a: mat2x3, out?: mat3): mat3
• static fromMat2d → fromMat2x3
• static fromQuat(q: quat, out?: mat3): mat3
• static normalFromMat4(a: mat4, out?: mat3): mat3 | null
• static fromMat4(a: mat4, out?: mat3): mat3
• static fromMat4x4 → fromMat4
• static projection(width: number, height: number, out?: mat3): mat3
• frob(): number
• plus(b: mat3, out?: mat3): mat3
• add → plus
• minus(b: mat3, out?: mat3): mat3
• sub → minus
• subtract → minus
• scaleScalar(b: number, out?: mat3): mat3
• multiplyScalar → scaleScalar
• multiplyScalarAndAdd(b: mat3, scale: number, out?: mat3): mat3
• toString(): string
• str → toString
• exactEquals(b: mat3): boolean
• equals(b: mat3): boolean

mat4

• clone(): mat4
• transpose(out?: mat4): mat4
• invert(out?: mat4): mat4 | null
• adjoint(out?: mat4): mat4
• determinant(): number
• multiply(b: vec2 | vec3 | vec4 | mat4, out?: mat4): vec2 | vec3 | vec4 | mat4
• mul → multiply
• mult → multiply
• times → multiply
• translate(v: vec3, out?: mat4): mat4
• scale(v: vec3, out?: mat4): mat4
• rotate(rad: number, axis: vec3, out?: mat4): mat4 | null
• rotateX(rad: number, out?: mat4): mat4
• rotateY(rad: number, out?: mat4): mat4
• rotateZ(rad: number, out?: mat4): mat4
• getTranslation(out?: vec3): vec3
• getScaling(out?: vec3): vec3
• getRotation(out?: quat): quat
• decompose(out_r?: quat, out_t?: vec3, out_s?: vec3): quat
• static fromTranslation(v: vec3, out?: mat4): mat4
• static fromScaling(v: vec3, out?: mat4): mat4
• static fromRotation(rad: number, axis: vec3, out?: mat4): mat4 | null
• static fromXRotation(rad: number, out?: mat4): mat4
• static fromYRotation(rad: number, out?: mat4): mat4
• static fromZRotation(rad: number, out?: mat4): mat4
• static fromRotationTranslation(q: quat, v: vec3, out?: mat4): mat4
• static fromRotationTranslationScale(q: quat, v: vec3, s: vec3, out?: mat4): mat4
• static fromRotationTranslationScaleOrigin(q: quat, v: vec3, s: vec3, o: vec3, out?: mat4): mat4
• static fromQuat(q: quat, out?: mat4): mat4
• static frustum(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: mat4): mat4
• static perspectiveNO(fovy: number, aspect: number, near: number, far: number | null, out?: mat4): mat4
• static perspectiveZO(fovy: number, aspect: number, near: number, far: number | null, out?: mat4): mat4
• static perspectiveFromFieldOfView(fov: { updegrees: number; downdegrees: number; leftdegrees: number; rightdegrees: number; }, near: number, far: number, out?: mat4): mat4
• static orthoNO(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: mat4): mat4
• static orthoZO(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: mat4): mat4
• static lookAt(eye: vec3, center: vec3, up: vec3, out?: mat4): mat4
• static targetTo(eye: vec3, target: vec3, up: vec3, out?: mat4): mat4
• static infinitePerspective(fovy: number, aspect: number, near: number, out?: mat4): mat4
• static project(obj: vec3, model: mat4, proj: mat4, viewport: vec4, out?: vec3): vec3
• static unProject(win: vec3, model: mat4, proj: mat4, viewport: vec4, out?: vec3): vec3 | null
• frob(): number
• plus(b: mat4, out?: mat4): mat4
• add → plus
• minus(b: mat4, out?: mat4): mat4
• sub → minus
• subtract → minus
• scaleScalar(b: number, out?: mat4): mat4
• multiplyScalar → scaleScalar
• multiplyScalarAndAdd(b: mat4, scale: number, out?: mat4): mat4
• toString(): string
• str → toString
• exactEquals(b: mat4): boolean
• equals(b: mat4): boolean

quat

• multiply(b: number | quat, out?: quat): quat
• mult → multiply
• mul → multiply
• scale → multiply
• times → multiply
• static fromAxisAngle(axis: vec3, rad: number, out?: quat): quat
• setAxisAngle(axis: vec3, rad: number, out?: quat): quat
• getAxisAngle(out_axis: vec3): number
• static angle(a: quat, b: quat): number
• static getAngle → angle
• rotateX(rad: number, out?: quat): quat
• rotateY(rad: number, out?: quat): quat
• rotateZ(rad: number, out?: quat): quat
• calculateW(): number
• static exp(q: quat, out?: quat): quat
• exp(out?: quat): quat
• static ln(q: quat, out?: quat): quat
• ln(out?: quat): quat
• pow(b: number): this
• static slerp(a: quat, b: quat, t: number, out?: quat): quat
• slerp(b: quat, t: number, out?: quat): quat
• static random(out?: quat): quat
• static invert(q: quat, out?: quat): quat
• invert(out?: quat): quat
• static conjugate(q: quat, out?: quat): quat
• conjugate(out?: quat): quat
• static fromMat3(m: mat3, out?: quat): quat
• static fromEuler(x: number, y: number, z: number, order?: string, out?: quat): quat
• toString(): string
• str → toString
• static dot(a: quat, b: quat): number
• dot(b: quat): number
• equals(b: quat): boolean
• static rotationTo(a: vec3, b: vec3, out?: quat): quat
• static sqlerp(a: quat, b: quat, c: quat, d: quat, t: number, out?: quat): quat
• static setAxes(view: vec3, right: vec3, up: vec3, out?: quat): quat
• normalize(out?: quat): quat
• static quatLookAt(direction: vec3, up: vec3, out?: quat): quat
• pitch(): number
• yaw(): number
• roll(): number
• eulerAngles(out?: vec3): vec3
• toMat3(out?: mat3): mat3
• toMat4(out?: mat4): mat4

quat2

• getReal(out?: quat): quat
• getDual(out?: quat): quat
• setReal(q: quat): this
• setDual(q: quat): this
• getTranslation(out?: vec3): vec3
• static fromRotationTranslation(q: quat, t: vec3, out?: quat2): quat2
• static fromTranslation(t: vec3, out?: quat2): quat2
• static fromRotation(q: quat, out?: quat2): quat2
• static fromMat4(m: mat4, out?: quat2): quat2
• clone(): quat2
• translate(v: vec3, out?: quat2): quat2
• conjugate(out?: quat2): quat2
• invert(out?: quat2): quat2
• squaredLength(): number
• sqrLen → squaredLength
• len(): number
• normalize(out?: quat2): quat2
• static dot(a: quat2, b: quat2): number
• static lerp(a: quat2, b: quat2, t: number, out?: quat2): quat2
• plus(b: quat2, out?: quat2): quat2
• add → plus
• scale(s: number, out?: quat2): quat2
• equals(b: quat2): boolean
• exactEquals(b: quat2): boolean
• toString(): string
• str → toString

vec2

• plus(b: number | vec2, out?: vec2): vec2
• add → plus
• minus(b: number | vec2, out?: vec2): vec2
• sub → minus
• subtract → minus
• mult(b: number | vec2, out?: vec2): vec2
• mul → mult
• multiply → mult
• scale → mult
• times → mult
• div(b: number | vec2, out?: vec2): vec2
• divide → div
• invDiv(a: number | vec2, out?: vec2): vec2
• rem(b: number | vec2, out?: vec2): vec2
• negate(out?: vec2): vec2
• neg → negate
• unaryMinus → negate
• unaryPlus(out?: vec2): vec2
• normalize(out?: vec2): vec2
• equals(b: vec2): boolean
• exactEquals(b: vec2): boolean
• squaredLength(): number
• sqrLen → squaredLength
• len(): number
• floor(out?: vec2): vec2
• round(out?: vec2): vec2
• ceil(out?: vec2): vec2
• inverse(out?: vec2): vec2
• clone(): vec2
• rotate(rad?: number, origin?: vec2, out?: vec2): vec2
• toString(): string
• str → toString
• static random(scale?: number, out?: vec2): vec2
• static angle(a: vec2, b: vec2): number
• static signedAngle(a: vec2, b: vec2): number
• static dot(a: vec2, b: vec2): number
• dot(b: vec2): number
• static cross(a: vec2, b: vec2, out?: vec3): vec3
• static distance(a: vec2, b: vec2): number
• static dist → distance
• static squaredDistance(a: vec2, b: vec2): number
• static sqrDist → squaredDistance
• static lerp(a: vec2, b: vec2, t: number, out?: vec2): vec2
• static max(a: vec2, b: vec2, out?: vec2): vec2
• static min(a: vec2, b: vec2, out?: vec2): vec2
• static clamp(v: vec2, min: number | vec2, max: number | vec2, out?: vec2): vec2
• static mix(a: vec2, b: vec2, t: number | vec2, out?: vec2): vec2
• lerpV → mix
• static smoothstep(edge0: number | vec2, edge1: number | vec2, v: vec2, out?: vec2): vec2
• scaleAndAdd(b: vec2, scale: number, out?: vec2): vec2
• abs(out?: vec2): vec2
• sign(out?: vec2): vec2
• fract(out?: vec2): vec2
• clamp(min: number | vec2, max: number | vec2, out?: vec2): vec2
• saturate(out?: vec2): vec2
• mix(b: vec2, t: number | vec2, out?: vec2): vec2
• lerpV → mix
• step(edge: number | vec2, out?: vec2): vec2
• smoothstep(edge0: number | vec2, edge1: number | vec2, out?: vec2): vec2
• transformMat2(m: mat2, out?: vec2): vec2
• transformMat2x2 → transformMat2
• transformMat2x3(m: mat2x3, out?: vec2): vec2
• transformMat2d → transformMat2x3
• transformMat3(m: mat3, out?: vec2): vec2
• transformMat3x3 → transformMat3
• transformMat4(m: mat4, out?: vec2): vec2
• transformMat4x4 → transformMat4
• static scaleAndAdd(a: vec2, b: vec2, scale: number, out?: vec2): vec2
• static reflect(I: vec2, N: vec2, out?: vec2): vec2

vec3

• plus(b: number | vec3, out?: vec3): vec3
• add → plus
• minus(b: number | vec3, out?: vec3): vec3
• sub → minus
• subtract → minus
• mult(b: number | vec3, out?: vec3): vec3
• mul → mult
• scale → mult
• multiply → mult
• times → mult
• div(b: number | vec3, out?: vec3): vec3
• divide → div
• invDiv(b: number | vec3, out?: vec3): vec3
• negate(out?: vec3): vec3
• neg → negate
• unaryMinus → negate
• unaryPlus(out?: vec3): vec3
• static normalize(v: vec3, out?: vec3): vec3
• normalize(out?: vec3): vec3
• equals(b: vec3): boolean
• exactEquals(b: vec3): boolean
• squaredLength(): number
• sqrLen → squaredLength
• len(): number
• static floor(v: vec3, out?: vec3): vec3
• static round(v: vec3, out?: vec3): vec3
• static ceil(v: vec3, out?: vec3): vec3
• floor(out?: vec3): vec3
• round(out?: vec3): vec3
• ceil(out?: vec3): vec3
• static inverse(v: vec3, out?: vec3): vec3
• inverse(out?: vec3): vec3
• clone(): vec3
• toString(): string
• str → toString
• static random(scale?: number): vec3
• static angle(a: vec3, b: vec3): number
• static dot(a: vec3, b: vec3): number
• static cross(a: vec3, b: vec3, out?: vec3): vec3
• static distance(a: vec3, b: vec3): number
• static dist → distance
• static squaredDistance(a: vec3, b: vec3): number
• static sqrDist → squaredDistance
• static lerp(a: vec3, b: vec3, t: number, out?: vec3): vec3
• static slerp(a: vec3, b: vec3, t: number, out?: vec3): vec3
• static max(a: vec3, b: vec3, out?: vec3): vec3
• static min(a: vec3, b: vec3, out?: vec3): vec3
• static clamp(v: vec3, min: number | vec3, max: number | vec3, out?: vec3): vec3
• static mix(a: vec3, b: vec3, t: number | vec3, out?: vec3): vec3
• static smoothstep(edge0: number | vec3, edge1: number | vec3, v: vec3, out?: vec3): vec3
• static rotateX(v: vec3, rad: number, origin?: vec3, out?: vec3): vec3
• rotateX(rad: number, origin?: vec3, out?: vec3): vec3
• static rotateY(v: vec3, rad: number, origin?: vec3, out?: vec3): vec3
• rotateY(rad: number, origin?: vec3, out?: vec3): vec3
• static rotateZ(v: vec3, rad: number, origin?: vec3, out?: vec3): vec3
• rotateZ(rad: number, origin?: vec3, out?: vec3): vec3
• static hermite(a: vec3, b: vec3, c: vec3, d: vec3, t: number, out?: vec3): vec3
• static bezier(a: vec3, b: vec3, c: vec3, d: vec3, t: number, out?: vec3): vec3
• static scaleAndAdd(a: vec3, b: vec3, scale: number, out?: vec3): vec3
• static reflect(I: vec3, N: vec3, out?: vec3): vec3
• static refract(I: vec3, N: vec3, eta: number, out?: vec3): vec3
• static faceforward(N: vec3, I: vec3, Nref: vec3, out?: vec3): vec3
• static triangleNormal(p1: vec3, p2: vec3, p3: vec3, out?: vec3): vec3
• static project(a: vec3, b: vec3, out?: vec3): vec3
• static orientedAngle(a: vec3, b: vec3, ref: vec3): number
• scaleAndAdd(b: vec3, scale: number, out?: vec3): vec3
• abs(out?: vec3): vec3
• clamp(min: number | vec3, max: number | vec3, out?: vec3): vec3
• mix(b: vec3, t: number | vec3, out?: vec3): vec3
• step(edge: number | vec3, out?: vec3): vec3
• smoothstep(edge0: number | vec3, edge1: number | vec3, out?: vec3): vec3
• fract(out?: vec3): vec3
• sign(out?: vec3): vec3
• saturate(out?: vec3): vec3
• transformMat3(m: mat3, out?: vec3): vec3
• transformMat3x3 → transformMat3
• transformMat4(m: mat4, out?: vec3): vec3
• transformMat4x4 → transformMat4
• transformQuat(q: quat, out?: vec3): vec3

vec4

• plus(b: number | vec4, out?: vec4): vec4
• add → plus
• minus(b: number | vec4, out?: vec4): vec4
• sub → minus
• subtract → minus
• mult(b: number | vec4, out?: vec4): vec4
• mul → mult
• scale → mult
• times → mult
• multiply → mult
• div(b: number | vec4, out?: vec4): vec4
• divide → div
• invDiv(b: number | vec4, out?: vec4): vec4
• negate(out?: vec4): vec4
• neg → negate
• unaryMinus → negate
• unaryPlus(out?: vec4): vec4
• normalize(out?: vec4): vec4
• equals(b: vec4): boolean
• exactEquals(b: vec4): boolean
• squaredLength(): number
• sqrLen → squaredLength
• len(): number
• floor(out?: vec4): vec4
• round(out?: vec4): vec4
• ceil(out?: vec4): vec4
• inverse(out?: vec4): vec4
• clone(): vec4
• toString(): string
• str → toString
• static random(scale?: number, out?: vec4): vec4
• static dot(a: vec4, b: vec4): number
• static cross(u: vec4, v: vec4, w: vec4, out?: vec4): vec4
• static distance(a: vec4, b: vec4): number
• static dist → distance
• static squaredDistance(a: vec4, b: vec4): number
• static sqrDist → squaredDistance
• static lerp(a: vec4, b: vec4, t: number, out?: vec4): vec4
• static max(a: vec4, b: vec4, out?: vec4): vec4
• static min(a: vec4, b: vec4, out?: vec4): vec4
• static clamp(v: vec4, min: number | vec4, max: number | vec4, out?: vec4): vec4
• static mix(a: vec4, b: vec4, t: number | vec4, out?: vec4): vec4
• static smoothstep(edge0: number | vec4, edge1: number | vec4, v: vec4, out?: vec4): vec4
• scaleAndAdd(b: vec4, scale: number, out?: vec4): vec4
• abs(out?: vec4): vec4
• clamp(min: number | vec4, max: number | vec4, out?: vec4): vec4
• mix(b: vec4, t: number | vec4, out?: vec4): vec4
• step(edge: number | vec4, out?: vec4): vec4
• smoothstep(edge0: number | vec4, edge1: number | vec4, out?: vec4): vec4
• fract(out?: vec4): vec4
• sign(out?: vec4): vec4
• saturate(out?: vec4): vec4
• transformMat4(m: mat4, out?: vec4): vec4
• transformMat4x4 → transformMat4
• transformQuat(q: quat, out?: vec4): vec4
• static scaleAndAdd(a: vec4, b: vec4, scale: number, out?: vec4): vec4

mat2x3

• invert(out?: mat2x3 | undefined): mat2x3 | null
• determinant(): number
• rotate(rad: number, out?: mat2x3 | undefined): mat2x3
• scale(v: vec2, out?: mat2x3 | undefined): mat2x3
• translate(v: vec2, out?: mat2x3 | undefined): mat2x3
• static fromRotation(rad: number, out?: mat2x3 | undefined): mat2x3
• static fromScaling(v: vec2, out?: mat2x3 | undefined): mat2x3
• static fromTranslation(v: vec2, out?: mat2x3 | undefined): mat2x3
• toString(): string
• frob(): number
• plus(b: mat2x3, out?: mat2x3 | undefined): mat2x3
• minus(b: mat2x3, out?: mat2x3 | undefined): mat2x3
• multiply(b: vec2): vec2
• multiply(b: mat2x3, out?: mat2x3 | undefined): mat2x3
• equals(b: mat2x3): boolean
• exactEquals(b: mat2x3): boolean
• scaleScalar(b: number, out?: mat2x3 | undefined): mat2x3
• clone(): mat2x3

mat3

• clone(): mat3
• transpose(out?: mat3 | undefined): mat3
• invert(out?: mat3 | undefined): mat3 | null
• adjoint(out?: mat3 | undefined): mat3
• determinant(): number
• multiply(b: vec2): vec2
• multiply(b: vec3): vec3
• multiply(b: mat3, out?: mat3 | undefined): mat3
• translate(v: vec2, out?: mat3 | undefined): mat3
• rotate(rad: number, out?: mat3 | undefined): mat3
• scale(v: vec2, out?: mat3 | undefined): mat3
• static fromTranslation(v: vec2, out?: mat3 | undefined): mat3
• static fromRotation(rad: number, out?: mat3 | undefined): mat3
• static fromScaling(v: vec2, out?: mat3 | undefined): mat3
• static fromMat2x3(a: mat2x3, out?: mat3 | undefined): mat3
• static fromQuat(q: quat, out?: mat3 | undefined): mat3
• static normalFromMat4(a: mat4, out?: mat3 | undefined): mat3 | null
• static fromMat4(a: mat4, out?: mat3 | undefined): mat3
• static projection(width: number, height: number, out?: mat3 | undefined): mat3
• frob(): number
• plus(b: mat3, out?: mat3 | undefined): mat3
• minus(b: mat3, out?: mat3 | undefined): mat3
• scaleScalar(b: number, out?: mat3 | undefined): mat3
• multiplyScalarAndAdd(b: mat3, scale: number, out?: mat3 | undefined): mat3
• toString(): string
• exactEquals(b: mat3): boolean
• equals(b: mat3): boolean

quat

• multiply(b: number | quat, out?: quat | undefined): quat
• static fromAxisAngle(axis: vec3, rad: number, out?: quat | undefined): quat
• setAxisAngle(axis: vec3, rad: number, out?: quat | undefined): quat
• getAxisAngle(out_axis: vec3): number
• static angle(a: quat, b: quat): number
• rotateX(rad: number, out?: quat | undefined): quat
• rotateY(rad: number, out?: quat | undefined): quat
• rotateZ(rad: number, out?: quat | undefined): quat
• calculateW(): number
• static exp(q: quat, out?: quat | undefined): quat
• exp(out?: quat | undefined): quat
• static ln(q: quat, out?: quat | undefined): quat
• ln(out?: quat | undefined): quat
• pow(b: number): this
• static slerp(a: quat, b: quat, t: number, out?: quat | undefined): quat
• slerp(b: quat, t: number, out?: quat | undefined): quat
• static random(out?: quat | undefined): quat
• static invert(q: quat, out?: quat | undefined): quat
• invert(out?: quat | undefined): quat
• static conjugate(q: quat, out?: quat | undefined): quat
• conjugate(out?: quat | undefined): quat
• static fromMat3(m: mat3, out?: quat | undefined): quat
• static fromEuler(x: number, y: number, z: number, order?: string | undefined, out?: quat | undefined): quat
• toString(): string
• static dot(a: quat, b: quat): number
• dot(b: quat): number
• equals(b: quat): boolean
• static rotationTo(a: vec3, b: vec3, out?: quat | undefined): quat
• static sqlerp(a: quat, b: quat, c: quat, d: quat, t: number, out?: quat | undefined): quat
• static setAxes(view: vec3, right: vec3, up: vec3, out?: quat | undefined): quat
• normalize(out?: quat | undefined): quat
• static quatLookAt(direction: vec3, up: vec3, out?: quat | undefined): quat
• pitch(): number
• yaw(): number
• roll(): number
• eulerAngles(out?: vec3 | undefined): vec3
• toMat3(out?: mat3 | undefined): mat3
• toMat4(out?: mat4 | undefined): mat4

mat4

• clone(): mat4
• transpose(out?: mat4 | undefined): mat4
• invert(out?: mat4 | undefined): mat4 | null
• adjoint(out?: mat4 | undefined): mat4
• determinant(): number
• multiply(b: vec2): vec2
• multiply(b: vec3): vec3
• multiply(b: vec4): vec4
• multiply(b: mat4, out?: mat4 | undefined): mat4
• translate(v: vec3, out?: mat4 | undefined): mat4
• scale(v: vec3, out?: mat4 | undefined): mat4
• rotate(rad: number, axis: vec3, out?: mat4 | undefined): mat4 | null
• rotateX(rad: number, out?: mat4 | undefined): mat4
• rotateY(rad: number, out?: mat4 | undefined): mat4
• rotateZ(rad: number, out?: mat4 | undefined): mat4
• getTranslation(out?: vec3 | undefined): vec3
• getScaling(out?: vec3 | undefined): vec3
• getRotation(out?: quat | undefined): quat
• decompose(out_r?: quat | undefined, out_t?: vec3 | undefined, out_s?: vec3 | undefined): quat
• static fromTranslation(v: vec3, out?: mat4 | undefined): mat4
• static fromScaling(v: vec3, out?: mat4 | undefined): mat4
• static fromRotation(rad: number, axis: vec3, out?: mat4 | undefined): mat4 | null
• static fromXRotation(rad: number, out?: mat4 | undefined): mat4
• static fromYRotation(rad: number, out?: mat4 | undefined): mat4
• static fromZRotation(rad: number, out?: mat4 | undefined): mat4
• static fromRotationTranslation(q: quat, v: vec3, out?: mat4 | undefined): mat4
• static fromRotationTranslationScale(q: quat, v: vec3, s: vec3, out?: mat4 | undefined): mat4
• static fromRotationTranslationScaleOrigin(q: quat, v: vec3, s: vec3, o: vec3, out?: mat4 | undefined): mat4
• static fromQuat(q: quat, out?: mat4 | undefined): mat4
• static frustum(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: mat4 | undefined): mat4
• static perspectiveNO(fovy: number, aspect: number, near: number, far: number | null, out?: mat4 | undefined): mat4
• static perspectiveZO(fovy: number, aspect: number, near: number, far: number | null, out?: mat4 | undefined): mat4
• static perspectiveFromFieldOfView(fov: { updegrees: number; downdegrees: number; leftdegrees: number; rightdegrees: number; }, near: number, far: number, out?: mat4 | undefined): mat4
• static orthoNO(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: mat4 | undefined): mat4
• static orthoZO(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: mat4 | undefined): mat4
• static lookAt(eye: vec3, center: vec3, up: vec3, out?: mat4 | undefined): mat4
• static targetTo(eye: vec3, target: vec3, up: vec3, out?: mat4 | undefined): mat4
• static infinitePerspective(fovy: number, aspect: number, near: number, out?: mat4 | undefined): mat4
• static project(obj: vec3, model: mat4, proj: mat4, viewport: vec4, out?: vec3 | undefined): vec3
• static unProject(win: vec3, model: mat4, proj: mat4, viewport: vec4, out?: vec3 | undefined): vec3 | null
• frob(): number
• plus(b: mat4, out?: mat4 | undefined): mat4
• minus(b: mat4, out?: mat4 | undefined): mat4
• scaleScalar(b: number, out?: mat4 | undefined): mat4
• multiplyScalarAndAdd(b: mat4, scale: number, out?: mat4 | undefined): mat4
• toString(): string
• exactEquals(b: mat4): boolean
• equals(b: mat4): boolean

vec4

• plus(b: number | vec4, out?: vec4 | undefined): vec4
• minus(b: number | vec4, out?: vec4 | undefined): vec4
• mult(b: number | vec4, out?: vec4 | undefined): vec4
• div(b: number | vec4, out?: vec4 | undefined): vec4
• invDiv(b: number | vec4, out?: vec4 | undefined): vec4
• negate(out?: vec4 | undefined): vec4
• unaryPlus(out?: vec4 | undefined): vec4
• normalize(out?: vec4 | undefined): vec4
• equals(b: vec4): boolean
• exactEquals(b: vec4): boolean
• squaredLength(): number
• len(): number
• floor(out?: vec4 | undefined): vec4
• round(out?: vec4 | undefined): vec4
• ceil(out?: vec4 | undefined): vec4
• inverse(out?: vec4 | undefined): vec4
• clone(): vec4
• toString(): string
• static random(scale?: number | undefined, out?: vec4 | undefined): vec4
• static dot(a: vec4, b: vec4): number
• static cross(u: vec4, v: vec4, w: vec4, out?: vec4 | undefined): vec4
• static distance(a: vec4, b: vec4): number
• static squaredDistance(a: vec4, b: vec4): number
• static lerp(a: vec4, b: vec4, t: number, out?: vec4 | undefined): vec4
• static max(a: vec4, b: vec4, out?: vec4 | undefined): vec4
• static min(a: vec4, b: vec4, out?: vec4 | undefined): vec4
• static clamp(v: vec4, min: number | vec4, max: number | vec4, out?: vec4 | undefined): vec4
• static mix(a: vec4, b: vec4, t: number | vec4, out?: vec4 | undefined): vec4
• static smoothstep(edge0: number | vec4, edge1: number | vec4, v: vec4, out?: vec4 | undefined): vec4
• scaleAndAdd(b: vec4, scale: number, out?: vec4 | undefined): vec4
• abs(out?: vec4 | undefined): vec4
• clamp(min: number | vec4, max: number | vec4, out?: vec4 | undefined): vec4
• mix(b: vec4, t: number | vec4, out?: vec4 | undefined): vec4
• step(edge: number | vec4, out?: vec4 | undefined): vec4
• smoothstep(edge0: number | vec4, edge1: number | vec4, out?: vec4 | undefined): vec4
• fract(out?: vec4 | undefined): vec4
• sign(out?: vec4 | undefined): vec4
• saturate(out?: vec4 | undefined): vec4
• transformMat4(m: mat4, out?: vec4 | undefined): vec4
• transformQuat(q: quat, out?: vec4 | undefined): vec4
• static scaleAndAdd(a: vec4, b: vec4, scale: number, out?: vec4 | undefined): vec4

vec3

• plus(b: number | vec3, out?: vec3 | undefined): vec3
• minus(b: number | vec3, out?: vec3 | undefined): vec3
• mult(b: number | vec3, out?: vec3 | undefined): vec3
• div(b: number | vec3, out?: vec3 | undefined): vec3
• invDiv(b: number | vec3, out?: vec3 | undefined): vec3
• negate(out?: vec3 | undefined): vec3
• unaryPlus(out?: vec3 | undefined): vec3
• static normalize(v: vec3, out?: vec3 | undefined): vec3
• normalize(out?: vec3 | undefined): vec3
• equals(b: vec3): boolean
• exactEquals(b: vec3): boolean
• squaredLength(): number
• len(): number
• static floor(v: vec3, out?: vec3 | undefined): vec3
• static round(v: vec3, out?: vec3 | undefined): vec3
• static ceil(v: vec3, out?: vec3 | undefined): vec3
• floor(out?: vec3 | undefined): vec3
• round(out?: vec3 | undefined): vec3
• ceil(out?: vec3 | undefined): vec3
• static inverse(v: vec3, out?: vec3 | undefined): vec3
• inverse(out?: vec3 | undefined): vec3
• clone(): vec3
• toString(): string
• static random(scale?: number | undefined): vec3
• static angle(a: vec3, b: vec3): number
• static dot(a: vec3, b: vec3): number
• static cross(a: vec3, b: vec3, out?: vec3 | undefined): vec3
• static distance(a: vec3, b: vec3): number
• static squaredDistance(a: vec3, b: vec3): number
• static lerp(a: vec3, b: vec3, t: number, out?: vec3 | undefined): vec3
• static slerp(a: vec3, b: vec3, t: number, out?: vec3 | undefined): vec3
• static max(a: vec3, b: vec3, out?: vec3 | undefined): vec3
• static min(a: vec3, b: vec3, out?: vec3 | undefined): vec3
• static clamp(v: vec3, min: number | vec3, max: number | vec3, out?: vec3 | undefined): vec3
• static mix(a: vec3, b: vec3, t: number | vec3, out?: vec3 | undefined): vec3
• static smoothstep(edge0: number | vec3, edge1: number | vec3, v: vec3, out?: vec3 | undefined): vec3
• static rotateX(v: vec3, rad: number, origin?: vec3 | undefined, out?: vec3 | undefined): vec3
• rotateX(rad: number, origin?: vec3 | undefined, out?: vec3 | undefined): vec3
• static rotateY(v: vec3, rad: number, origin?: vec3 | undefined, out?: vec3 | undefined): vec3
• rotateY(rad: number, origin?: vec3 | undefined, out?: vec3 | undefined): vec3
• static rotateZ(v: vec3, rad: number, origin?: vec3 | undefined, out?: vec3 | undefined): vec3
• rotateZ(rad: number, origin?: vec3 | undefined, out?: vec3 | undefined): vec3
• static hermite(a: vec3, b: vec3, c: vec3, d: vec3, t: number, out?: vec3 | undefined): vec3
• static bezier(a: vec3, b: vec3, c: vec3, d: vec3, t: number, out?: vec3 | undefined): vec3
• static scaleAndAdd(a: vec3, b: vec3, scale: number, out?: vec3 | undefined): vec3
• static reflect(I: vec3, N: vec3, out?: vec3 | undefined): vec3
• static refract(I: vec3, N: vec3, eta: number, out?: vec3 | undefined): vec3
• static faceforward(N: vec3, I: vec3, Nref: vec3, out?: vec3 | undefined): vec3
• static triangleNormal(p1: vec3, p2: vec3, p3: vec3, out?: vec3 | undefined): vec3
• static project(a: vec3, b: vec3, out?: vec3 | undefined): vec3
• static orientedAngle(a: vec3, b: vec3, ref: vec3): number
• scaleAndAdd(b: vec3, scale: number, out?: vec3 | undefined): vec3
• abs(out?: vec3 | undefined): vec3
• clamp(min: number | vec3, max: number | vec3, out?: vec3 | undefined): vec3
• mix(b: vec3, t: number | vec3, out?: vec3 | undefined): vec3
• step(edge: number | vec3, out?: vec3 | undefined): vec3
• smoothstep(edge0: number | vec3, edge1: number | vec3, out?: vec3 | undefined): vec3
• fract(out?: vec3 | undefined): vec3
• sign(out?: vec3 | undefined): vec3
• saturate(out?: vec3 | undefined): vec3
• transformMat3(m: mat3, out?: vec3 | undefined): vec3
• transformMat4(m: mat4, out?: vec3 | undefined): vec3
• transformQuat(q: quat, out?: vec3 | undefined): vec3

mat2

• clone(): mat2
• transpose(out?: mat2 | undefined): mat2
• invert(out?: mat2 | undefined): mat2 | null
• adjoint(out?: mat2 | undefined): mat2
• determinant(): number
• rotate(rad: number, out?: mat2 | undefined): mat2
• scale(v: vec2, out?: mat2 | undefined): mat2
• static fromRotation(rad: number, out?: mat2 | undefined): mat2
• static fromScaling(v: vec2, out?: mat2 | undefined): mat2
• toString(): string
• frob(): number
• LDU(L?: mat2 | undefined, D?: mat2 | undefined, U?: mat2 | undefined): mat2[]
• plus(b: mat2, out?: mat2 | undefined): mat2
• minus(b: mat2, out?: mat2 | undefined): mat2
• multiply(b: vec2): vec2
• multiply(b: mat2, out?: mat2 | undefined): mat2
• exactEquals(b: mat2): boolean
• equals(b: mat2): boolean
• scaleScalar(b: number, out?: mat2 | undefined): mat2

vec2

• plus(b: number | vec2, out?: vec2 | undefined): vec2
• minus(b: number | vec2, out?: vec2 | undefined): vec2
• mult(b: number | vec2, out?: vec2 | undefined): vec2
• div(b: number | vec2, out?: vec2 | undefined): vec2
• invDiv(a: number | vec2, out?: vec2 | undefined): vec2
• rem(b: number | vec2, out?: vec2 | undefined): vec2
• negate(out?: vec2 | undefined): vec2
• unaryPlus(out?: vec2 | undefined): vec2
• normalize(out?: vec2 | undefined): vec2
• equals(b: vec2): boolean
• exactEquals(b: vec2): boolean
• squaredLength(): number
• len(): number
• floor(out?: vec2 | undefined): vec2
• round(out?: vec2 | undefined): vec2
• ceil(out?: vec2 | undefined): vec2
• inverse(out?: vec2 | undefined): vec2
• clone(): vec2
• rotate(rad?: number | undefined, origin?: vec2 | undefined, out?: vec2 | undefined): vec2
• toString(): string
• static random(scale?: number | undefined, out?: vec2 | undefined): vec2
• static angle(a: vec2, b: vec2): number
• static signedAngle(a: vec2, b: vec2): number
• static dot(a: vec2, b: vec2): number
• dot(b: vec2): number
• static cross(a: vec2, b: vec2, out?: vec3 | undefined): vec3
• static distance(a: vec2, b: vec2): number
• static squaredDistance(a: vec2, b: vec2): number
• static lerp(a: vec2, b: vec2, t: number, out?: vec2 | undefined): vec2
• static max(a: vec2, b: vec2, out?: vec2 | undefined): vec2
• static min(a: vec2, b: vec2, out?: vec2 | undefined): vec2
• static clamp(v: vec2, min: number | vec2, max: number | vec2, out?: vec2 | undefined): vec2
• static mix(a: vec2, b: vec2, t: number | vec2, out?: vec2 | undefined): vec2
• static smoothstep(edge0: number | vec2, edge1: number | vec2, v: vec2, out?: vec2 | undefined): vec2
• scaleAndAdd(b: vec2, scale: number, out?: vec2 | undefined): vec2
• abs(out?: vec2 | undefined): vec2
• sign(out?: vec2 | undefined): vec2
• fract(out?: vec2 | undefined): vec2
• clamp(min: number | vec2, max: number | vec2, out?: vec2 | undefined): vec2
• saturate(out?: vec2 | undefined): vec2
• mix(b: vec2, t: number | vec2, out?: vec2 | undefined): vec2
• step(edge: number | vec2, out?: vec2 | undefined): vec2
• smoothstep(edge0: number | vec2, edge1: number | vec2, out?: vec2 | undefined): vec2
• transformMat2(m: mat2, out?: vec2 | undefined): vec2
• transformMat2x3(m: mat2x3, out?: vec2 | undefined): vec2
• transformMat3(m: mat3, out?: vec2 | undefined): vec2
• transformMat4(m: mat4, out?: vec2 | undefined): vec2
• static scaleAndAdd(a: vec2, b: vec2, scale: number, out?: vec2 | undefined): vec2
• static reflect(I: vec2, N: vec2, out?: vec2 | undefined): vec2

quat2

• getReal(out?: quat | undefined): quat
• getDual(out?: quat | undefined): quat
• setReal(q: quat): this
• setDual(q: quat): this
• getTranslation(out?: vec3 | undefined): vec3
• static fromRotationTranslation(q: quat, t: vec3, out?: quat2 | undefined): quat2
• static fromTranslation(t: vec3, out?: quat2 | undefined): quat2
• static fromRotation(q: quat, out?: quat2 | undefined): quat2
• static fromMat4(m: mat4, out?: quat2 | undefined): quat2
• clone(): quat2
• translate(v: vec3, out?: quat2 | undefined): quat2
• conjugate(out?: quat2 | undefined): quat2
• invert(out?: quat2 | undefined): quat2
• squaredLength(): number
• len(): number
• normalize(out?: quat2 | undefined): quat2
• static dot(a: quat2, b: quat2): number
• static lerp(a: quat2, b: quat2, t: number, out?: quat2 | undefined): quat2
• plus(b: quat2, out?: quat2 | undefined): quat2
• scale(s: number, out?: quat2 | undefined): quat2
• equals(b: quat2): boolean
• exactEquals(b: quat2): boolean
• toString(): string

Benchmark results

You can run benchmark with npm run bench.

Suprisingly, in most operations glmaths comes faster than its simpler gl-matrix library? I honestly quite skeptical about it.

This benchmark, though, doesn't tell the difference in loading up a library. When I started running benchmarks, I noticed how on first test glmaths was consistently slower, than gl-matrix; and I believe this is a setup cost for extending Float32Array with all methods and getters for swizzles. There is a hack in bencmark.js to overcome this.

Benchmark Results

Benchmark was run on my Macbook Pro M4.

Tests

You can run tests with npm run test