gl-matrix (master)

# include()

Pull in the contents of an external file at the given path.

# makeSignature()

Build output for displaying function parameters.

# makeSortby()

Make a symbol sorter by some attribute.

# makeSrcFile()

Turn a raw source file into a code-hilited page in the docs.

# publish()

Called automatically by JsDoc Toolkit.

# resolveLinks()

Find symbol {@link ...} strings in text and turn into html links

# summarize()

Just the first sentence (up to a full stop). Should not break on dotted variable names.

# equals(a, b)

Tests whether or not the arguments have approximately the same value, within an absolute or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less than or equal to 1.0, and a relative tolerance is used for larger values)

Parameters

# round(a)

Symmetric round see https://www.npmjs.com/package/round-half-up-symmetric#user-content-detailed-background

Parameters

# setMatrixArrayType(type)

Sets the type of array used when creating new vectors and matrices

Parameters

# toDegree(a)

Convert Radian To Degree

Parameters

# toRadian(a)

Convert Degree To Radian

Parameters

# add(out, a, b)

Adds two mat2's

Parameters

# adjoint(out, a)

Calculates the adjugate of a mat2

Parameters

# clone(a)

Creates a new mat2 initialized with values from an existing matrix

Parameters

# copy(out, a)

Copy the values from one mat2 to another

Parameters

# create()

Creates a new identity mat2

# determinant(a)

Calculates the determinant of a mat2

Parameters

# equals(a, b)

Returns whether or not the matrices have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)

Parameters

# frob(a)

Returns Frobenius norm of a mat2

Parameters

# fromRotation(out, a, v)

Scales the mat2 by the dimensions in the given vec2

Parameters

# fromScaling(out, v)

Creates a matrix from a vector scaling This is equivalent to (but much faster than): mat2.identity(dest); mat2.scale(dest, dest, vec);

Parameters

# fromValues(m00, m01, m10, m11)

Create a new mat2 with the given values

Parameters

# identity(out)

Set a mat2 to the identity matrix

Parameters

# invert(out, a)

Inverts a mat2

Parameters

# LDU(L, D, U, a)

Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix

Parameters

# mul()

Alias for {@link mat2.multiply}

# multiply(out, a, b)

Multiplies two mat2's

Parameters

# multiplyScalar(out, a, b)

Multiply each element of the matrix by a scalar.

Parameters

# multiplyScalarAndAdd(out, a, b, scale)

Adds two mat2's after multiplying each element of the second operand by a scalar value.

Parameters

# rotate(out, a, rad)

Rotates a mat2 by the given angle

Parameters

# set(out, m00, m01, m10, m11)

Set the components of a mat2 to the given values

Parameters

# str(a)

Returns a string representation of a mat2

Parameters

# sub()

Alias for {@link mat2.subtract}

# subtract(out, a, b)

Subtracts matrix b from matrix a

Parameters

# transpose(out, a)

Transpose the values of a mat2

Parameters

# add(out, a, b)

Adds two mat2d's

Parameters

# clone(a)

Creates a new mat2d initialized with values from an existing matrix

Parameters

# copy(out, a)

Copy the values from one mat2d to another

Parameters

# create()

Creates a new identity mat2d

# determinant(a)

Calculates the determinant of a mat2d

Parameters

# equals(a, b)

Returns whether or not the matrices have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)

Parameters

# frob(a)

Returns Frobenius norm of a mat2d

Parameters

# fromRotation(out, a, v)

Scales the mat2d by the dimensions in the given vec2

Parameters

# fromScaling(out, v)

Creates a matrix from a vector scaling This is equivalent to (but much faster than): mat2d.identity(dest); mat2d.scale(dest, dest, vec);

Parameters

# fromTranslation(out, v)

Creates a matrix from a vector translation This is equivalent to (but much faster than): mat2d.identity(dest); mat2d.translate(dest, dest, vec);

Parameters

# fromValues(a, b, c, d, tx, ty)

Create a new mat2d with the given values

Parameters

# identity(out)

Set a mat2d to the identity matrix

Parameters

# invert(out, a)

Inverts a mat2d

Parameters

# mul()

Alias for {@link mat2d.multiply}

# multiply(out, a, b)

Multiplies two mat2d's

Parameters

# multiplyScalar(out, a, b)

Multiply each element of the matrix by a scalar.

Parameters

# multiplyScalarAndAdd(out, a, b, scale)

Adds two mat2d's after multiplying each element of the second operand by a scalar value.

Parameters

# rotate(out, a, rad)

Rotates a mat2d by the given angle

Parameters

# set(out, a, b, c, d, tx, ty)

Set the components of a mat2d to the given values

Parameters

# str(a)

Returns a string representation of a mat2d

Parameters

# sub()

Alias for {@link mat2d.subtract}

# subtract(out, a, b)

Subtracts matrix b from matrix a

Parameters

# add(out, a, b)

Adds two mat3's

Parameters

# adjoint(out, a)

Calculates the adjugate of a mat3

Parameters

# clone(a)

Creates a new mat3 initialized with values from an existing matrix

Parameters

# copy(out, a)

Copy the values from one mat3 to another

Parameters

# create()

Creates a new identity mat3

# determinant(a)

Calculates the determinant of a mat3

Parameters

# equals(a, b)

Returns whether or not the matrices have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)

Parameters

# frob(a)

Returns Frobenius norm of a mat3

Parameters

# fromMat4(out, a)

Copies the upper-left 3x3 values into the given mat3.

Parameters

# fromQuat(out, a)

Copies the values from a mat2d into a mat3

Parameters

# fromRotation(out, rad)

Creates a matrix from a given angle This is equivalent to (but much faster than): mat3.identity(dest); mat3.rotate(dest, dest, rad);

Parameters

# fromScaling(out, v)

Creates a matrix from a vector scaling This is equivalent to (but much faster than): mat3.identity(dest); mat3.scale(dest, dest, vec);

Parameters

# fromTranslation(out, a, v)

Scales the mat3 by the dimensions in the given vec2

Parameters

# fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22)

Create a new mat3 with the given values

Parameters

# identity(out)

Set a mat3 to the identity matrix

Parameters

# invert(out, a)

Inverts a mat3

Parameters

# mul()

Alias for {@link mat3.multiply}

# multiply(out, a, b)

Multiplies two mat3's

Parameters

# multiplyScalar(out, a, b)

Multiply each element of the matrix by a scalar.

Parameters

# multiplyScalarAndAdd(out, a, b, scale)

Adds two mat3's after multiplying each element of the second operand by a scalar value.

Parameters

# normalFromMat4(out, a)

Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix

Parameters

# projection(out, width, height)

Generates a 2D projection matrix with the given bounds

Parameters

# rotate(out, a, rad)

Rotates a mat3 by the given angle

Parameters

# set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22)

Set the components of a mat3 to the given values

Parameters

# str(a)

Returns a string representation of a mat3

Parameters

# sub()

Alias for {@link mat3.subtract}

# subtract(out, a, b)

Subtracts matrix b from matrix a

Parameters

# translate(out, a, v)

Translate a mat3 by the given vector

Parameters

# transpose(out, a)

Transpose the values of a mat3

Parameters

# add(out, a, b)

Adds two mat4's

Parameters

# adjoint(out, a)

Calculates the adjugate of a mat4

Parameters

# clone(a)

Creates a new mat4 initialized with values from an existing matrix

Parameters

# copy(out, a)

Copy the values from one mat4 to another

Parameters

# create()

Creates a new identity mat4

# decompose(out_r, out_t, out_s, mat)

Decomposes a transformation matrix into its rotation, translation and scale components. Returns only the rotation component

Parameters

# determinant(a)

Calculates the determinant of a mat4

Parameters

# equals(a, b)

Returns whether or not the matrices have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)

Parameters

# frob(a)

Returns Frobenius norm of a mat4

Parameters

# fromQuat(out, q)

Calculates a 4x4 matrix from the given quaternion

Parameters

# fromQuat2(out, a)

Creates a new mat4 from a dual quat.

Parameters

# fromRotation(out, rad, axis)

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

Parameters

# fromRotationTranslation(out, q, v)

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

Parameters

# fromRotationTranslationScale(out, q, v, s)

Creates a matrix from a quaternion rotation, vector translation and vector scale This is equivalent to (but much faster than): mat4.identity(dest); mat4.translate(dest, vec); let quatMat = mat4.create(); quat4.toMat4(quat, quatMat); mat4.multiply(dest, quatMat); mat4.scale(dest, scale)

Parameters

# fromRotationTranslationScaleOrigin(out, q, v, s, o)

Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin This is equivalent to (but much faster than): mat4.identity(dest); mat4.translate(dest, vec); mat4.translate(dest, origin); let quatMat = mat4.create(); quat4.toMat4(quat, quatMat); mat4.multiply(dest, quatMat); mat4.scale(dest, scale) mat4.translate(dest, negativeOrigin);

Parameters

# fromScaling(out, v)

Creates a matrix from a vector scaling This is equivalent to (but much faster than): mat4.identity(dest); mat4.scale(dest, dest, vec);

Parameters

# fromTranslation(out, v)

Creates a matrix from a vector translation This is equivalent to (but much faster than): mat4.identity(dest); mat4.translate(dest, dest, vec);

Parameters

# fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33)

Create a new mat4 with the given values

Parameters

# fromXRotation(out, rad)

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

Parameters

# fromYRotation(out, rad)

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

Parameters

# fromZRotation(out, rad)

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

Parameters

# frustum(out, left, right, bottom, top, near, far)

Generates a frustum matrix with the given bounds

Parameters

# getRotation(out, mat)

Returns a quaternion representing the rotational component of a transformation matrix. If a matrix is built with fromRotationTranslation, the returned quaternion will be the same as the quaternion originally supplied.

Parameters

Returns

quat

out

# getScaling(out, mat)

Returns the scaling factor component of a transformation matrix. If a matrix is built with fromRotationTranslationScale with a normalized Quaternion paramter, the returned vector will be the same as the scaling vector originally supplied.

Parameters

Returns

vec3

out

# getTranslation(out, mat)

Returns the translation vector component of a transformation matrix. If a matrix is built with fromRotationTranslation, the returned vector will be the same as the translation vector originally supplied.

Parameters

Returns

vec3

out

# identity(out)

Set a mat4 to the identity matrix

Parameters

# invert(out, a)

Inverts a mat4

Parameters

# lookAt(out, eye, center, up)

Generates a look-at matrix with the given eye position, focal point, and up axis. If you want a matrix that actually makes an object look at another object, you should use targetTo instead.

Parameters

# mul()

Alias for {@link mat4.multiply}

# multiply(out, a, b)

Multiplies two mat4s

Parameters

# multiplyScalar(out, a, b)

Multiply each element of the matrix by a scalar.

Parameters

# multiplyScalarAndAdd(out, a, b, scale)

Adds two mat4's after multiplying each element of the second operand by a scalar value.

Parameters

# ortho()

Alias for {@link mat4.orthoNO}

# orthoNO(out, left, right, bottom, top, near, far)

Generates a orthogonal projection matrix with the given bounds. The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1], which matches WebGL/OpenGL's clip volume.

Parameters

# orthoZO(out, left, right, bottom, top, near, far)

Generates a orthogonal projection matrix with the given bounds. The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1], which matches WebGPU/Vulkan/DirectX/Metal's clip volume.

Parameters

# perspective()

Alias for {@link mat4.perspectiveNO}

# perspectiveFromFieldOfView(out, fov, near, far)

Generates a perspective projection matrix with the given field of view. This is primarily useful for generating projection matrices to be used with the still experiemental WebVR API.

Parameters

# perspectiveNO(out, fovy, aspect, near, far)

Generates a perspective projection matrix with the given bounds. The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1], which matches WebGL/OpenGL's clip volume. Passing null/undefined/no value for far will generate infinite projection matrix.

Parameters

# perspectiveZO(out, fovy, aspect, near, far)

Generates a perspective projection matrix suitable for WebGPU with the given bounds. The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1], which matches WebGPU/Vulkan/DirectX/Metal's clip volume. Passing null/undefined/no value for far will generate infinite projection matrix.

Parameters

# rotate(out, a, v)

Scales the mat4 by the dimensions in the given vec3 not using vectorization

Parameters

# rotateX(out, a, rad)

Rotates a matrix by the given angle around the X axis

Parameters

# rotateY(out, a, rad)

Rotates a matrix by the given angle around the Y axis

Parameters

# rotateZ(out, a, rad)

Rotates a matrix by the given angle around the Z axis

Parameters

# set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33)

Set the components of a mat4 to the given values

Parameters

# str(a)

Returns a string representation of a mat4

Parameters

# sub()

Alias for {@link mat4.subtract}

# subtract(out, a, b)

Subtracts matrix b from matrix a

Parameters

# targetTo(out, eye, center, up)

Generates a matrix that makes something look at something else.

Parameters

# translate(out, a, v)

Translate a mat4 by the given vector

Parameters

# transpose(out, a)

Transpose the values of a mat4

Parameters

# add(out, a, b)

Adds two quat's

Parameters

# calculateW(out, a)

Calculates the W component of a quat from the X, Y, and Z components. Assumes that quaternion is 1 unit in length. Any existing W component will be ignored.

Parameters

# clone(a)

Creates a new quat initialized with values from an existing quaternion

Parameters

# conjugate(out, a)

Calculates the conjugate of a quat If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.

Parameters

# copy(out, a)

Copy the values from one quat to another

Parameters

# create()

Creates a new identity quat

# dot(a, b)

Calculates the dot product of two quat's

Parameters

# equals(a, b)

Returns whether or not the quaternions point approximately to the same direction. Both quaternions are assumed to be unit length.

Parameters

# exactEquals(a, b)

Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)

Parameters

# exp(out, a)

Calculate the exponential of a unit quaternion.

Parameters

# fromEuler(out, x, y, z, order)

Creates a quaternion from the given euler angle x, y, z using the provided intrinsic order for the conversion.

Parameters

# fromMat3(out, m)

Creates a quaternion from the given 3x3 rotation matrix. NOTE: The resultant quaternion is not normalized, so you should be sure to renormalize the quaternion yourself where necessary.

Parameters

# fromValues(x, y, z, w)

Creates a new quat initialized with the given values

Parameters

# getAngle(a, b)

Gets the angular distance between two unit quaternions

Parameters

Returns

Number

Angle, in radians, between the two quaternions

# getAxisAngle(out, axis, rad)

Sets a quat from the given angle and rotation axis, then returns it.

Parameters

# identity(out)

Set a quat to the identity quaternion

Parameters

# invert(out, a)

Calculates the inverse of a quat

Parameters

# len()

Alias for {@link quat.length}

# length(a)

Calculates the length of a quat

Parameters

# lerp(out, a, b, t)

Performs a linear interpolation between two quat's

Parameters

# ln(out, a)

Calculate the natural logarithm of a unit quaternion.

Parameters

# mul()

Alias for {@link quat.multiply}

# multiply(out, a, b)

Multiplies two quat's

Parameters

# normalize(out, a)

Normalize a quat

Parameters

# pow(out, a, b)

Calculate the scalar power of a unit quaternion.

Parameters

# random(out)

Generates a random unit quaternion

Parameters

# rotateX(out, a, rad)

Rotates a quaternion by the given angle about the X axis

Parameters

# rotateY(out, a, rad)

Rotates a quaternion by the given angle about the Y axis

Parameters

# rotateZ(out, a, rad)

Rotates a quaternion by the given angle about the Z axis

Parameters

# rotationTo(out, a, b)

Sets a quaternion to represent the shortest rotation from one vector to another. Both vectors are assumed to be unit length.

Parameters

# scale(out, a, b)

Scales a quat by a scalar number

Parameters

# set(out, x, y, z, w)

Set the components of a quat to the given values

Parameters

# setAxes(view, right, up)

Sets the specified quaternion with values corresponding to the given axes. Each axis is a vec3 and is expected to be unit length and perpendicular to all other specified axes.

Parameters

# slerp(out, a, b, t)

Performs a spherical linear interpolation between two quat

Parameters

# sqlerp(out, a, b, c, d, t)

Performs a spherical linear interpolation with two control points

Parameters

# sqrLen()

Alias for {@link quat.squaredLength}

# squaredLength(a)

Calculates the squared length of a quat

Parameters

# str(a)

Returns a string representation of a quaternion

Parameters

# add(out, a, b)

Adds two dual quat's

Parameters

# clone(a)

Creates a new quat initialized with values from an existing quaternion

Parameters

# conjugate(out, a)

Calculates the conjugate of a dual quat If the dual quaternion is normalized, this function is faster than quat2.inverse and produces the same result.

Parameters

# copy(out, a)

Copy the values from one dual quat to another

Parameters

# create()

Creates a new identity dual quat

# dot(a, b)

Calculates the dot product of two dual quat's (The dot product of the real parts)

Parameters

# equals(a, b)

Returns whether or not the dual quaternions have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the dual quaternions have exactly the same elements in the same position (when compared with ===)

Parameters

# fromMat4(out, a)

Creates a new dual quat from a matrix (4x4)

Parameters

# fromRotation(dual, q)

Creates a dual quat from a quaternion

Parameters

# fromRotationTranslation(dual, q, t)

Creates a dual quat from a quaternion and a translation

Parameters

# fromRotationTranslationValues(x1, y1, z1, w1, x2, y2, z2)

Creates a new dual quat from the given values (quat and translation)

Parameters

# fromTranslation(dual, t)

Creates a dual quat from a translation

Parameters

# fromValues(x1, y1, z1, w1, x2, y2, z2, w2)

Creates a new dual quat initialized with the given values

Parameters

# getDual(out, a)

Gets the dual part of a dual quat

Parameters

Returns

quat

dual part

# getReal(out, a)

Gets the real part of a dual quat

Parameters

Returns

quat

real part

# getTranslation(out, a)

Gets the translation of a normalized dual quat

Parameters

Returns

vec3

translation

# identity(out)

Set a dual quat to the identity dual quaternion

Parameters

# invert(out, a)

Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper

Parameters

# len()

Alias for {@link quat2.length}

# length(a)

Calculates the length of a dual quat

Parameters

# lerp(out, a, b, t)

Performs a linear interpolation between two dual quats's NOTE: The resulting dual quaternions won't always be normalized (The error is most noticeable when t = 0.5)

Parameters

# mul()

Alias for {@link quat2.multiply}

# multiply(out, a, b)

Multiplies two dual quat's

Parameters

# normalize(out, a)

Normalize a dual quat

Parameters

# rotateAroundAxis(out, a, axis, rad)

Rotates a dual quat around a given axis. Does the normalisation automatically

Parameters

# rotateByQuatAppend(out, a, q)

Rotates a dual quat by a given quaternion (a * q)

Parameters

# rotateByQuatPrepend(out, q, a)

Rotates a dual quat by a given quaternion (q * a)

Parameters

# rotateX(out, a, rad)

Rotates a dual quat around the X axis

Parameters

# rotateY(out, a, rad)

Rotates a dual quat around the Y axis

Parameters

# rotateZ(out, a, rad)

Rotates a dual quat around the Z axis

Parameters

# scale(out, a, b)

Scales a dual quat by a scalar number

Parameters

# set(out, x1, y1, z1, w1, x2, y2, z2, w2)

Set the components of a dual quat to the given values

Parameters

# setDual(out, q)

Set the dual component of a dual quat to the given quaternion

Parameters

# setReal(out, q)

Set the real component of a dual quat to the given quaternion

Parameters

# sqrLen()

Alias for {@link quat2.squaredLength}

# squaredLength(a)

Calculates the squared length of a dual quat

Parameters

# str(a)

Returns a string representation of a dual quaternion

Parameters

# translate(out, a, v)

Translates a dual quat by the given vector

Parameters

# add(out, a, b)

Adds two vec2's

Parameters

# angle(a, b)

Get the angle between two 2D vectors

Parameters

# ceil(out, a)

Math.ceil the components of a vec2

Parameters

# clone(a)

Creates a new vec2 initialized with values from an existing vector

Parameters

# copy(out, a)

Copy the values from one vec2 to another

Parameters

# create()

Creates a new, empty vec2

# cross(out, a, b)

Computes the cross product of two vec2's Note that the cross product must by definition produce a 3D vector

Parameters

# dist()

Alias for {@link vec2.distance}

# distance(a, b)

Calculates the euclidian distance between two vec2's

Parameters

# div()

Alias for {@link vec2.divide}

# divide(out, a, b)

Divides two vec2's

Parameters

# dot(a, b)

Calculates the dot product of two vec2's

Parameters

# equals(a, b)

Returns whether or not the vectors have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)

Parameters

# floor(out, a)

Math.floor the components of a vec2

Parameters

# forEach(a, stride, offset, count, fn, arg)

Perform some operation over an array of vec2s.

Parameters

# fromValues(x, y)

Creates a new vec2 initialized with the given values

Parameters

# inverse(out, a)

Returns the inverse of the components of a vec2

Parameters

# len()

Alias for {@link vec2.length}

# length(a)

Calculates the length of a vec2

Parameters

# lerp(out, a, b, t)

Performs a linear interpolation between two vec2's

Parameters

# max(out, a, b)

Returns the maximum of two vec2's

Parameters

# min(out, a, b)

Returns the minimum of two vec2's

Parameters

# mul()

Alias for {@link vec2.multiply}

# multiply(out, a, b)

Multiplies two vec2's

Parameters

# negate(out, a)

Negates the components of a vec2

Parameters

# normalize(out, a)

Normalize a vec2

Parameters

# random(out, scale)

Generates a random vector with the given scale

Parameters

# rotate(out, a, b, rad)

Rotate a 2D vector

Parameters

# round(out, a)

symmetric round the components of a vec2

Parameters

# scale(out, a, b)

Scales a vec2 by a scalar number

Parameters

# scaleAndAdd(out, a, b, scale)

Adds two vec2's after scaling the second operand by a scalar value

Parameters

# set(out, x, y)

Set the components of a vec2 to the given values

Parameters

# sqrDist()

Alias for {@link vec2.squaredDistance}

# sqrLen()

Alias for {@link vec2.squaredLength}

# squaredDistance(a, b)

Calculates the squared euclidian distance between two vec2's

Parameters

# squaredLength(a)

Calculates the squared length of a vec2

Parameters

# str(a)

Returns a string representation of a vector

Parameters

# sub()

Alias for {@link vec2.subtract}

# subtract(out, a, b)

Subtracts vector b from vector a

Parameters

# transformMat2(out, a, m)

Transforms the vec2 with a mat2

Parameters

# transformMat2d(out, a, m)

Transforms the vec2 with a mat2d

Parameters

# transformMat3(out, a, m)

Transforms the vec2 with a mat3 3rd vector component is implicitly '1'

Parameters

# transformMat4(out, a, m)

Transforms the vec2 with a mat4 3rd vector component is implicitly '0' 4th vector component is implicitly '1'

Parameters

# zero(out)

Set the components of a vec2 to zero

Parameters

# add(out, a, b)

Adds two vec3's

Parameters

# angle(a, b)

Get the angle between two 3D vectors

Parameters

# bezier(out, a, b, c, d, t)

Performs a bezier interpolation with two control points

Parameters

# ceil(out, a)

Math.ceil the components of a vec3

Parameters

# clone(a)

Creates a new vec3 initialized with values from an existing vector

Parameters

# copy(out, a)

Copy the values from one vec3 to another

Parameters

# create()

Creates a new, empty vec3

# cross(out, a, b)

Computes the cross product of two vec3's

Parameters

# dist()

Alias for {@link vec3.distance}

# distance(a, b)

Calculates the euclidian distance between two vec3's

Parameters

# div()

Alias for {@link vec3.divide}

# divide(out, a, b)

Divides two vec3's

Parameters

# dot(a, b)

Calculates the dot product of two vec3's

Parameters

# equals(a, b)

Returns whether or not the vectors have approximately the same elements in the same position.

Parameters

# exactEquals(a, b)

Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)

Parameters

# floor(out, a)

Math.floor the components of a vec3

Parameters

# forEach(a, stride, offset, count, fn, arg)

Perform some operation over an array of vec3s.

Parameters

# fromValues(x, y, z)

Creates a new vec3 initialized with the given values

Parameters

# hermite(out, a, b, c, d, t)

Performs a hermite interpolation with two control points

Parameters

# inverse(out, a)

Returns the inverse of the components of a vec3

Parameters

# len()

Alias for {@link vec3.length}

# length(a)

Calculates the length of a vec3

Parameters

# lerp(out, a, b, t)

Performs a linear interpolation between two vec3's

Parameters

# max(out, a, b)

Returns the maximum of two vec3's

Parameters

# min(out, a, b)

Returns the minimum of two vec3's

Parameters

# mul()

Alias for {@link vec3.multiply}

# multiply(out, a, b)

Multiplies two vec3's

Parameters

# negate(out, a)

Negates the components of a vec3

Parameters

# normalize(out, a)

Normalize a vec3

Parameters

# random(out, scale)

Generates a random vector with the given scale

Parameters

# rotateX(out, a, b, rad)

Rotate a 3D vector around the x-axis

Parameters

# rotateY(out, a, b, rad)

Rotate a 3D vector around the y-axis

Parameters

# rotateZ(out, a, b, rad)

Rotate a 3D vector around the z-axis

Parameters

# round(out, a)

symmetric round the components of a vec3

Parameters

# scale(out, a, b)

Scales a vec3 by a scalar number

Parameters

# scaleAndAdd(out, a, b, scale)

Adds two vec3's after scaling the second operand by a scalar value

Parameters

# set(out, x, y, z)

Set the components of a vec3 to the given values

Parameters

# slerp(out, a, b, t)

Performs a spherical linear interpolation between two vec3's

Parameters

# sqrDist()

Alias for {@link vec3.squaredDistance}

# sqrLen()

Alias for {@link vec3.squaredLength}

# squaredDistance(a, b)

Calculates the squared euclidian distance between two vec3's

Parameters

# squaredLength(a)

Calculates the squared length of a vec3

Parameters

# str(a)

Returns a string representation of a vector

Parameters

# sub()

Alias for {@link vec3.subtract}

# subtract(out, a, b)

Subtracts vector b from vector a

Parameters

# transformMat3(out, a, m)

Transforms the vec3 with a mat3.

Parameters

# transformMat4(out, a, m)

Transforms the vec3 with a mat4. 4th vector component is implicitly '1'

Parameters

# transformQuat(out, a, q)

Transforms the vec3 with a quat Can also be used for dual quaternions. (Multiply it with the real part)

Parameters