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: + - * / % == ===

const ndc = proj * view * vertex
let model = mat4()
model *= mat4.fromRotation(Math.PI / 2, vec3(0, 1, 0))
vec4(vec2(1.0, 2.0) / 2.0 + 4.0, 0.0, 1.0) + vec4(1) * vec4(4, 2, 0, 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)

The idea behind glmaths is to make tinkering fun — so by default every operation returns a new copy, and you can just write a.plus(b) without thinking about memory. But when you need performance, you can pre-allocate structures and pass them as out, just like you would in gl-matrix.

You can also set glmaths.ALWAYS_COPY = false to make instance methods modify the structure in place by default, skipping the copy entirely. But this can bring confusion, hence why this is not the default:

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

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
• static normalize(q: quat, out?: quat): quat
• normalized → normalize
• normalize(out?: quat): quat
• normalized → normalize
• 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
• static normalize(q: quat2, out?: quat2): quat2
• normalized → normalize
• normalize(out?: quat2): quat2
• normalized → normalize
• 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
• static normalize(v: vec2, out?: vec2): vec2
• normalized → normalize
• normalize(out?: vec2): vec2
• normalized → normalize
• 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
• normalized → normalize
• normalize(out?: vec3): vec3
• normalized → normalize
• 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
• static normalize(v: vec4, out?: vec4): vec4
• normalized → normalize
• normalize(out?: vec4): vec4
• normalized → normalize
• 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
• static normalize(q: quat, 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
• static normalize(v: vec4, 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
• static normalize(v: vec2, 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
• static normalize(q: quat2, out?: quat2 | undefined): quat2
• 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 is run with glmaths.ALWAYS_COPY = false.

Tests

You can run tests with npm run test