# math types¶

## vec2¶

class vec2
static vec2(x)
static vec2(x, y)

Create a new `vec2` by setting both values at once or each one individually

static min(v1, v2)

Return a `vec2` containing the component-wise minimum of two vectors

static max(v1, v2)

Return a `vec2` containing the component-wise maximum two vectors

x: number

The x component of this vector

y: number

The y component of this vector

length: number

The length of this vector

length2: number

The squared length of this vector

normalize()

Normalize this vector

normalized()

Return a normalized copy of this vector

dot(v)

Perform a scalar dot product with another vector and return the result

distance(v)

Calculate the distance (i.e. L1 norm) to another vector

distance2(v)

Calculate the squared distance (i.e. L2 norm) to another vector

reflect(normal)

refract(normal, ior)

Refract this vector though another with a given index or refraction

lerp(v, t)

Interpolate this vector with another by the a given factor (typically between 0 and 1)

abs()

Return a copy of this vector with component-wise absolute values

unpack() x, y

Unpack this vector as multiple number values

## vec3¶

class vec3
static vec3(x)
static vec3(x, y, z)

Create a new `vec3` by setting all values at once or each one individually

static min(v1, v2)

Return a `vec3` containing the component-wise minimum of two vectors

static max(v1, v2)

Return a `vec3` containing the component-wise maximum two vectors

x: number

The x component of this vector

y: number

The y component of this vector

z: number

The z component of this vector

length: number

The length of this vector

length2: number

The squared length of this vector

normalize()

Normalize this vector

normalized()

Return a normalized copy of this vector

dot(v)

Perform a scalar dot product with another vector and return the result

cross(v)

Perform a cross product with another vec3 and return the result

distance(v)

Calculate the distance (i.e. L1 norm) to another vector

distance2(v)

Calculate the squared distance (i.e. L2 norm) to another vector

reflect(normal)

refract(normal, ior)

Refract this vector though another with a given index or refraction

lerp(v, t)

Interpolate this vector with another by the a given factor (typically between 0 and 1)

abs()

Return a copy of this vector with component-wise absolute values

unpack() x, y, z

Unpack this vector as multiple number values

## vec4¶

class vec4
static vec4(x)
static vec4(x, y, z, w)

Create a new `vec4` by setting all values at once or each one individually

static min(v1, v2)

Return a `vec4` containing the component-wise minimum of two vectors

static max(v1, v2)

Return a `vec4` containing the component-wise maximum two vectors

x: number

The x component of this vector

y: number

The y component of this vector

z: number

The z component of this vector

w: number

The w component of this vector

length: number

The length of this vector

length2: number

The squared length of this vector

normalize()

Normalize this vector

normalized()

Return a normalized copy of this vector

dot(v)

Perform a scalar dot product with another vector and return the result

distance(v)

Calculate the distance (i.e. L1 norm) to another vector

distance2(v)

Calculate the squared distance (i.e. L2 norm) to another vector

reflect(normal)

refract(normal, ior)

Refract this vector though another with a given index or refraction

lerp(v, t)

Interpolate this vector with another by the a given factor (typically between 0 and 1)

abs()

Return a copy of this vector with component-wise absolute values

unpack() x, y, z, w

Unpack this vector as multiple number values

## quat¶

class quat
static quat()
static quat(x, y, z, w)

Create a new `quat`

static lookRotation(forward, up)
Returns

A `quat` that points in the `forward` direction using `up` to orient it correctly

static fromToRotate(from, to)
Parameters
• from (`vec3`) – The direction to rotate from

• to (`vec3`) – The direction to rotate to

Returns

a `quat` containing a relative rotation between the `from` and `to` vectors

static angleAxis(angle, axis)
Parameters
• angle (`number`) – The amount of rotation in degrees

• axis (`vec3`) – The axis of rotation

Returns

a new `quat` containing a rotation defined by `angle` (in degrees) rotated about the `axis` vector

static eulerAngles(x, y, z)
Parameters
• x (`number`) – The amount of rotation about the x axis (yaw) in degrees

• y (`number`) – The amount of rotation about the y axis (pitch) in degrees

• z (`number`) – The amount of rotation about the z axis (roll) in degrees

Returns

a new `quat` containing a rotation defined by 3 euler angles (i.e. yaw, pitch roll) in radians

x: number

The x component of this vector

y: number

The y component of this vector

z: number

The z component of this vector

w: number

The w component of this vector

angles: vec3

A set of euler angles (in degrees) that generates the same rotation as this quaternion

Please note that the potential euler angles from any given quaternion are ambiguous and should not be relied upon for smooth or consistent rotations especially when interpolating them

slerp(q, t)
Parameters
• q – The other quaternion to slerp to

• t – The amount of interpolation (from 0 to 1)

Returns

a new `quat` that is spherically interpolated from this quaternion to `q` via `t` (between 0 and 1)

conjugate()
Returns

a new `quat` containing the conjugate of this quaternion

normalize()

Normalizes this quaternion

normalized()
Returns

a normalized copy of this quaternion

## mat2¶

class mat2

A simple 2x2 matrix

Each entry can be accessed via an index as well

```m = mat2(1) -- init with diagonals set to 1
print(m) -- prints '1.0'
```
static mat2()
static mat2(s)
static mat2(v1, v2)
static mat2(m11, m12, m21, m22)

Create a new `mat2`, default, diagonals, 2 `vec2` objects or all 4 entries

inverse()
Returns

the inverse of this matrix

transpose()
Returns

the transpose of this matrix

determinant()
Returns

the determinant of this matrix

row(index)
Returns

the row at a given `index` (starting at 1)

Return type

`vec2`

column(index)
Returns

the column at a given `index` (starting at 1)

Return type

`vec2`

## mat3¶

class mat2

A simple 3x3 matrix

Each entry can be accessed via an index as well

```m = mat3(1) -- init with diagonals set to 1
print(m) -- prints '1.0'
```
static mat3()
static mat3(s)
static mat3(v1, v2, v3)
static mat3(m11, m12, m31, ..., m33)

Create a new `mat3`, default, diagonals, 3 `vec3` objects or all 9 entries

inverse()
Returns

the inverse of this matrix

transpose()
Returns

the transpose of this matrix

determinant()
Returns

the determinant of this matrix

row(index)
Returns

the row at a given `index` (starting at 1)

Return type

`vec3`

column(index)
Returns

the column at a given `index` (starting at 1)

Return type

`vec3`

## mat4¶

class mat2

A simple 4x4 matrix, typically used for 3D homogonous transformations

Each entry can be accessed via an index as well

```m = mat4(1) -- init with diagonals set to 1
print(m) -- prints '1.0'
```
static mat4()
static mat4(s)
static mat4(v1, v2, v3, v4)
static mat4(m11, m12, m31, m41, ..., m44)

Create a new `mat4`, default, diagonals, 4 `vec4` objects or all 16 entries

static lookAt(eye, center, up)
static lookAt(matrix, eye, center, up)
static orbit(origin, distance, x, y)
static orbit(matrix, origin, distance, x, y)
static ortho(left, right, top, bottom[, near, far])
static perspective(fovy, aspect, near, far)
static rotate(angle, axis)
static rotate(matrix, angle, axis)
inverse()
Returns

the inverse of this matrix

transpose()
Returns

the transpose of this matrix

determinant()
Returns

the determinant of this matrix

row(index)
Returns

the row at a given `index` (starting at 1)

Return type

`vec3`

column(index)
Returns

the column at a given `index` (starting at 1)

Return type

`vec3`

## aabb¶

class bounds.aabb