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)¶
Reflect this vector about another
- 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)¶
Reflect this vector about another
- 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)¶
Reflect this vector about another
- 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 theforward
direction usingup
to orient it correctly
- static fromToRotate(from, to)¶
- Parameters:
from (
vec3
) – The direction to rotate fromto (
vec3
) – The direction to rotate to
- Returns:
a
quat
containing a relative rotation between thefrom
andto
vectors
- static angleAxis(angle, axis)¶
- Parameters:
angle (
number
) – The amount of rotation in degreesaxis (
vec3
) – The axis of rotation
- Returns:
a new
quat
containing a rotation defined byangle
(in degrees) rotated about theaxis
vector
- static eulerAngles(x, y, z)¶
- Parameters:
x (
number
) – The amount of rotation about the x axis (yaw) in degreesy (
number
) – The amount of rotation about the y axis (pitch) in degreesz (
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 toq
viat
(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[1]) -- prints '1.0'
- static mat2()¶
- static mat2(s)
- static mat2(v1, v2)
- static mat2(m11, m12, m21, m22)
Create a new
mat2
, default, diagonals, 2vec2
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[1]) -- 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, 3vec3
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[1]) -- 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, 4vec4
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¶