The `goog.vec.Matrix4` Namespace

`.Type`

@typedef: {goog.vec.ArrayType}

`.add(mat0, mat1, resultMat)`

Performs a per-component addition of the matrix mat0 and mat1, storing the result into resultMat.

mat0 {goog.vec.ArrayType}: The first addend.
mat1 {goog.vec.ArrayType}: The second addend.
resultMat {goog.vec.ArrayType}: The matrix to receive the results (may be either mat0 or mat1).
returns {goog.vec.ArrayType}: return resultMat so that operations can be chained together.

`.applyRotate(mat, angle, x, y, z)`

Applies a rotation by angle about the x,y,z axis to the given matrix.

mat {goog.vec.ArrayType}: The matrix.
angle {number}: The angle in radians.
x {number}: The x component of the rotation axis.
y {number}: The y component of the rotation axis.
z {number}: The z component of the rotation axis.

`.applyScale(mat, x, y, z)`

Applies an x,y,z scale to the given matrix.

mat {goog.vec.ArrayType}: The matrix.
x {number}: The x scale factor.
y {number}: The y scale factor.
z {number}: The z scale factor.

`.applyTranslate(mat, x, y, z)`

Applies a translation by x,y,z to the given matrix.

mat {goog.vec.ArrayType}: The matrix.
x {number}: The translation along the x axis.
y {number}: The translation along the y axis.
z {number}: The translation along the z axis.

`.clone`

Creates a clone of a 4x4 matrix.

matrix {goog.vec.Matrix4.Type}: The source 4x4 matrix.
returns {goog.vec.Matrix4.Type}: The new, 16 element matrix.

`.create()`

Creates the array representation of a 4x4 matrix. The use of the array directly eliminates any overhead associated with the class representation defined above. The returned matrix is cleared to all zeros.

returns {goog.vec.Matrix4.Type}: The new, sixteen element array.

`.createFromArray(matrix)`

Creates a 4x4 matrix initialized from the given array.

matrix {goog.vec.ArrayType}: The array containing the matrix values in column major order.
returns {goog.vec.Matrix4.Type}: The new, 16 element array.

`.createFromValues(v00, v10, v20, v30, v01, v11, v21, v31, v02, v12, v22, v32, v03, v13, v23, v33)`

Creates a 4x4 matrix initialized from the given values.

v00 {number}: The values at (0, 0).
v10 {number}: The values at (1, 0).
v20 {number}: The values at (2, 0).
v30 {number}: The values at (3, 0).
v01 {number}: The values at (0, 1).
v11 {number}: The values at (1, 1).
v21 {number}: The values at (2, 1).
v31 {number}: The values at (3, 1).
v02 {number}: The values at (0, 2).
v12 {number}: The values at (1, 2).
v22 {number}: The values at (2, 2).
v32 {number}: The values at (3, 2).
v03 {number}: The values at (0, 3).
v13 {number}: The values at (1, 3).
v23 {number}: The values at (2, 3).
v33 {number}: The values at (3, 3).
returns {goog.vec.Matrix4.Type}: The new, 16 element array.

`.createIdentity()`

returns {goog.vec.Matrix4.Type}: The new, sixteen element array.

`.determinant(mat)`

Computes the determinant of the matrix.

mat {goog.vec.ArrayType}: The matrix to compute the matrix for.
returns {number}: The determinant of the matrix.

`.equals(mat0, mat1)`

Returns true if the components of mat0 are equal to the components of mat1.

mat0 {goog.vec.ArrayType}: The first matrix.
mat1 {goog.vec.ArrayType}: The second matrix.
returns {boolean}: True if the the two matrices are equivalent.

`.fromEulerZXZ(matrix, theta1, theta2, theta3)`

Constructs a rotation matrix from its Euler angles using the ZXZ convention. Given the euler angles [theta1, theta2, theta3], the rotation is defined as rotation = rotation_z(theta1) * rotation_x(theta2) * rotation_z(theta3), where rotation_x(theta) means rotation around the X axis of theta radians.

matrix {goog.vec.ArrayType}: The rotation matrix.
theta1 {number}: The angle of rotation around the Z axis in radians.
theta2 {number}: The angle of rotation around the X axis in radians.
theta3 {number}: The angle of rotation around the Z axis in radians.

`.getColumn(mat, column, vec)`

Retrieves the specified column from the matrix into the given vector array.

mat {goog.vec.ArrayType}: The matrix supplying the values.
column {number}: The column to get the values from.
vec {goog.vec.ArrayType}: The vector of elements to receive the column.

`.getColumns(mat, vec0, vec1, vec2, vec3)`

Retrieves the column values from the given matrix into the given vector elements.

mat {goog.vec.ArrayType}: The matrix containing the columns to retrieve.
vec0 {goog.vec.ArrayType}: The vector elements to receive column 0.
vec1 {goog.vec.ArrayType}: The vector elements to receive column 1.
vec2 {goog.vec.ArrayType}: The vector elements to receive column 2.
vec3 {goog.vec.ArrayType}: The vector elements to receive column 3.

`.getElement(mat, row, column)`

Retrieves the element at the requested row and column.

mat {goog.vec.ArrayType}: The matrix containing the value to retrieve.
row {number}: The row index.
column {number}: The column index.
returns {number}: The element value at the requested row, column indices.

`.getRow(mat, row, vec)`

Retrieves the row values into the given vector.

mat {goog.vec.ArrayType}: The matrix supplying the values.
row {number}: The index of the row supplying the values.
vec {goog.vec.ArrayType}: The vector to receive the row.

`.getRows(mat, vec0, vec1, vec2, vec3)`

Retrieves the rows of the matrix into the supplied vectors.

mat {goog.vec.ArrayType}: The matrix to supply the values.
vec0 {goog.vec.ArrayType}: The vector to receive row 0.
vec1 {goog.vec.ArrayType}: The vector to receive row 1.
vec2 {goog.vec.ArrayType}: The vector to receive row 2.
vec3 {goog.vec.ArrayType}: The vector to receive row 3.

`.invert(mat, resultMat)`

Computes the inverse of mat storing the result into resultMat. If the inverse is defined, this function returns true, false otherwise.

mat {goog.vec.ArrayType}: The matrix to invert.
resultMat {goog.vec.ArrayType}: The matrix to receive the result (may be mat).
returns {boolean}: True if the inverse is defined. If false is returned, resultMat is not modified.

`.lookAt(viewMatrix, eyePt, centerPt, worldUpVec)`

Updates a matrix representing the modelview matrix of a camera so that the camera is 'looking at' the given center point.

viewMatrix {goog.vec.ArrayType}: The matrix.
eyePt {goog.vec.ArrayType}: The position of the eye point (camera origin).
centerPt {goog.vec.ArrayType}: The point to aim the camera at.
worldUpVec {goog.vec.ArrayType}: The vector that identifies the up direction for the camera.

`.makeAxisAngleRotate(mat, angle, ax, ay, az)`

Initializes the given 4x4 matrix as a rotation matrix with the given rotation angle about the axis defined by the vector (ax, ay, az).

mat {goog.vec.ArrayType}: The 4x4 (16-element) matrix array to receive the new translation matrix.
angle {number}: The rotation angle in radians.
ax {number}: The x component of the rotation axis.
ay {number}: The y component of the rotation axis.
az {number}: The z component of the rotation axis.

`.makeFrustum(mat, left, right, bottom, top, near, far)`

Initializes the given 4x4 matrix as a perspective projection matrix.

mat {goog.vec.ArrayType}: The 4x4 (16-element) matrix array to receive the new translation matrix.
left {number}: The coordinate of the left clipping plane.
right {number}: The coordinate of the right clipping plane.
bottom {number}: The coordinate of the bottom clipping plane.
top {number}: The coordinate of the top clipping plane.
near {number}: The distance to the near clipping plane.
far {number}: The distance to the far clipping plane.

`.makeOrtho(mat, left, right, bottom, top, near, far)`

Initializes the given 4x4 matrix as an orthographic projection matrix.

mat {goog.vec.ArrayType}: The 4x4 (16-element) matrix array to receive the new translation matrix.
left {number}: The coordinate of the left clipping plane.
right {number}: The coordinate of the right clipping plane.
bottom {number}: The coordinate of the bottom clipping plane.
top {number}: The coordinate of the top clipping plane.
near {number}: The distance to the near clipping plane.
far {number}: The distance to the far clipping plane.

`.makePerspective(mat, fovy, aspect, near, far)`

Initializes the given 4x4 matrix as a perspective projection matrix given a field of view and aspect ratio.

mat {goog.vec.ArrayType}: The 4x4 (16-element) matrix array to receive the new translation matrix.
fovy {number}: The field of view along the y (vertical) axis in radians.
aspect {number}: The x (width) to y (height) aspect ratio.
near {number}: The distance to the near clipping plane.
far {number}: The distance to the far clipping plane.

`.makeScale(mat, x, y, z)`

Initializes the given 4x4 matrix as a scale matrix with x, y and z scale factors.

mat {goog.vec.ArrayType}: The 4x4 (16-element) matrix array to receive the new translation matrix.
x {number}: The scale along the x axis.
y {number}: The scale along the y axis.
z {number}: The scale along the z axis.

`.makeTranslate(mat, x, y, z)`

Initializes the given 4x4 matrix as a translation matrix with x, y and z translation factors.

mat {goog.vec.ArrayType}: The 4x4 (16-element) matrix array to receive the new translation matrix.
x {number}: The translation along the x axis.
y {number}: The translation along the y axis.
z {number}: The translation along the z axis.

`.multMat(mat0, mat1, resultMat)`

Multiplies the two matrices mat0 and mat1 using matrix multiplication, storing the result into resultMat.

mat0 {goog.vec.ArrayType}: The first (left hand) matrix.
mat1 {goog.vec.ArrayType}: The second (right hand) matrix.
resultMat {goog.vec.ArrayType}: The matrix to receive the results (may be either mat0 or mat1).
returns {goog.vec.ArrayType}: return resultMat so that operations can be chained together.

`.multVec3(mat, vec, resultVec)`

Transforms the given vector with the given matrix storing the resulting, transformed vector into resultVec. The input vector is multiplied against the upper 3x4 matrix omitting the projective component.

mat {goog.vec.ArrayType}: The matrix supplying the transformation.
vec {goog.vec.ArrayType}: The 3 element vector to transform.
resultVec {goog.vec.ArrayType}: The 3 element vector to receive the results (may be vec).
returns {goog.vec.ArrayType}: return resultVec so that operations can be chained together.

`.multVec3NoTranslate(mat, vec, resultVec)`

Transforms the given vector with the given matrix storing the resulting, transformed vector into resultVec. The input vector is multiplied against the upper 3x3 matrix omitting the projective component and translation components.

mat {goog.vec.ArrayType}: The matrix supplying the transformation.
vec {goog.vec.ArrayType}: The 3 element vector to transform.
resultVec {goog.vec.ArrayType}: The 3 element vector to receive the results (may be vec).
returns {goog.vec.ArrayType}: return resultVec so that operations can be chained together.

`.multVec3Projective(mat, vec, resultVec)`

Transforms the given vector with the given matrix storing the resulting, transformed vector into resultVec. The input vector is multiplied against the full 4x4 matrix with the homogeneous divide applied to reduce the 4 element vector to a 3 element vector.

mat {goog.vec.ArrayType}: The matrix supplying the transformation.
vec {goog.vec.ArrayType}: The 3 element vector to transform.
resultVec {goog.vec.ArrayType}: The 3 element vector to receive the results (may be vec).
returns {goog.vec.ArrayType}: return resultVec so that operations can be chained together.

`.multVec3ToArray(mat, vec, resultVec)`

Transforms the given vector with the given matrix storing the resulting, transformed vector into resultVec. The input matrix is multiplied against the upper 3x4 matrix omitting the projective component.

mat {goog.vec.ArrayType}: The matrix supplying the transformation.
vec {goog.vec.ArrayType}: The 3 element vector to transform.
resultVec {goog.vec.ArrayType}: The 3 element vector to receive the results (may be vec).
returns {goog.vec.ArrayType}: return resultVec so that operations can be chained together.

`.multVec4(mat, vec, resultVec)`

Transforms the given vector with the given matrix storing the resulting, transformed vector into resultVec.

mat {goog.vec.ArrayType}: The matrix supplying the transformation.
vec {goog.vec.ArrayType}: The vector to transform.
resultVec {goog.vec.ArrayType}: The vector to receive the results (may be vec).
returns {goog.vec.ArrayType}: return resultVec so that operations can be chained together.

`.multVec4ToArray(mat, vec, resultVec)`

Transforms the given vector with the given matrix storing the resulting, transformed vector into resultVec.

mat {goog.vec.ArrayType}: The matrix supplying the transformation.
vec {goog.vec.ArrayType}: The vector to transform.
resultVec {goog.vec.ArrayType}: The vector to receive the results (may be vec).
returns {goog.vec.ArrayType}: return resultVec so that operations can be chained together.

`.scale(mat0, scalar, resultMat)`

Performs a component-wise multiplication of mat0 with the given scalar storing the result into resultMat.

mat0 {goog.vec.ArrayType}: The matrix to scale.
scalar {number}: The scalar value to multiple to each element of mat0.
resultMat {goog.vec.ArrayType}: The matrix to receive the results (may be mat0).
returns {goog.vec.ArrayType}: return resultMat so that operations can be chained together.

`.setColumn(mat, column, vec)`

Sets the specified column with the value from the supplied array.

mat {goog.vec.ArrayType}: The matrix to receive the values.
column {number}: The column index to set the values on.
vec {goog.vec.ArrayType}: The vector of elements for the column.

`.setColumnValues(mat, column, v0, v1, v2, v3)`

Sets the specified column with the supplied values.

mat {goog.vec.ArrayType}: The matrix to recieve the values.
column {number}: The column index to set the values on.
v0 {number}: The value for row 0.
v1 {number}: The value for row 1.
v2 {number}: The value for row 2.
v3 {number}: The value for row 3.

`.setColumns(mat, vec0, vec1, vec2, vec3)`

Sets the columns of the matrix from the set of vector elements.

mat {goog.vec.ArrayType}: The matrix to receive the values.
vec0 {goog.vec.ArrayType}: The values for column 0.
vec1 {goog.vec.ArrayType}: The values for column 1.
vec2 {goog.vec.ArrayType}: The values for column 2.
vec3 {goog.vec.ArrayType}: The values for column 3.

`.setDiagonal(mat, vec)`

Sets the diagonal values of the matrix from the given vector.

mat {goog.vec.ArrayType}: The matrix to receive the values.
vec {goog.vec.ArrayType}: The vector containing the values.

`.setDiagonalValues(mat, v00, v11, v22, v33)`

Sets the diagonal values of the matrix from the given values.

mat {goog.vec.ArrayType}: The matrix to receive the values.
v00 {number}: The values for (0, 0).
v11 {number}: The values for (1, 1).
v22 {number}: The values for (2, 2).
v33 {number}: The values for (3, 3).

`.setElement(mat, row, column, value)`

Sets the element at the requested row and column.

mat {goog.vec.ArrayType}: The matrix containing the value to retrieve.
row {number}: The row index.
column {number}: The column index.
value {number}: The value to set at the requested row, column.

`.setFromArray(mat, values)`

Sets the matrix from the array of values stored in column major order.

mat {goog.vec.ArrayType}: The matrix to receive the values.
values {goog.vec.ArrayType}: The column major ordered array of values to store in the matrix.

`.setFromRowMajorArray(mat, values)`

Sets the matrix from the array of values stored in row major order.

mat {goog.vec.ArrayType}: The matrix to receive the values.
values {goog.vec.ArrayType}: The row major ordered array of values to store in the matrix.

`.setFromValues(mat, v00, v10, v20, v30, v01, v11, v21, v31, v02, v12, v22, v32, v03, v13, v23, v33)`

Initializes the matrix from the set of values. Note the values supplied are in column major order.

mat {goog.vec.ArrayType}: The matrix to receive the values.
v00 {number}: The values at (0, 0).
v10 {number}: The values at (1, 0).
v20 {number}: The values at (2, 0).
v30 {number}: The values at (3, 0).
v01 {number}: The values at (0, 1).
v11 {number}: The values at (1, 1).
v21 {number}: The values at (2, 1).
v31 {number}: The values at (3, 1).
v02 {number}: The values at (0, 2).
v12 {number}: The values at (1, 2).
v22 {number}: The values at (2, 2).
v32 {number}: The values at (3, 2).
v03 {number}: The values at (0, 3).
v13 {number}: The values at (1, 3).
v23 {number}: The values at (2, 3).
v33 {number}: The values at (3, 3).

`.setIdentity(mat)`

Sets the given matrix to the identity matrix.

mat {goog.vec.ArrayType}: The matrix to set.

`.setRow(mat, row, vec)`

Sets the row values from the supplied vector.

mat {goog.vec.ArrayType}: The matrix to receive the row values.
row {number}: The index of the row.
vec {goog.vec.ArrayType}: The vector containing the values.

`.setRowValues(mat, row, v0, v1, v2, v3)`

Sets the row values from the supplied values.

mat {goog.vec.ArrayType}: The matrix to receive the values.
row {number}: The index of the row to receive the values.
v0 {number}: The value for column 0.
v1 {number}: The value for column 1.
v2 {number}: The value for column 2.
v3 {number}: The value for column 3.

`.setRows(mat, vec0, vec1, vec2, vec3)`

Sets the rows of the matrix from the supplied vectors.

mat {goog.vec.ArrayType}: The matrix to receive the values.
vec0 {goog.vec.ArrayType}: The values for row 0.
vec1 {goog.vec.ArrayType}: The values for row 1.
vec2 {goog.vec.ArrayType}: The values for row 2.
vec3 {goog.vec.ArrayType}: The values for row 3.

`.setZero(mat)`

Clears the given matrix to zero.

mat {goog.vec.ArrayType}: The matrix to clear.

`.subtract(mat0, mat1, resultMat)`

Performs a per-component subtraction of the matrix mat0 and mat1, storing the result into resultMat.

mat0 {goog.vec.ArrayType}: The minuend.
mat1 {goog.vec.ArrayType}: The subtrahend.
resultMat {goog.vec.ArrayType}: The matrix to receive the results (may be either mat0 or mat1).
returns {goog.vec.ArrayType}: return resultMat so that operations can be chained together.

`.toEulerZXZ(matrix, euler)`

Decomposes a rotation matrix into Euler angles using the ZXZ convention.

matrix {goog.vec.ArrayType}: The rotation matrix.
euler {goog.vec.ArrayType}: The ZXZ Euler angles in radians. euler = [roll, tilt, pan].

`.toLookAt(viewMatrix, eyePt, fwdVec, worldUpVec)`

Decomposes a matrix into the lookAt vectors eyePt, fwdVec and worldUpVec. The matrix represents the modelview matrix of a camera. It is the inverse of lookAt except for the output of the fwdVec instead of centerPt. The centerPt itself cannot be recovered from a modelview matrix.

viewMatrix {goog.vec.ArrayType}: The matrix.
eyePt {goog.vec.ArrayType}: The position of the eye point (camera origin).
fwdVec {goog.vec.ArrayType}: The vector describing where the camera points to.
worldUpVec {goog.vec.ArrayType}: The vector that identifies the up direction for the camera.
returns {boolean}: True if the method succeeds, false otherwise. The method can only fail if the inverse of viewMatrix is not defined.

`.transpose(mat, resultMat)`

Transposes the given matrix mat storing the result into resultMat.

mat {goog.vec.ArrayType}: The matrix to transpose.
resultMat {goog.vec.ArrayType}: The matrix to receive the results (may be mat).
returns {goog.vec.ArrayType}: return resultMat so that operations can be chained together.

The goog.vec.Matrix4 Namespace

.Type

.add(mat0, mat1, resultMat)

.applyRotate(mat, angle, x, y, z)

.applyScale(mat, x, y, z)

.applyTranslate(mat, x, y, z)

.clone

.create()

.createFromArray(matrix)

.createFromValues(v00, v10, v20, v30, v01, v11, v21, v31, v02, v12, v22, v32, v03, v13, v23, v33)

.createIdentity()

.determinant(mat)

.equals(mat0, mat1)

.fromEulerZXZ(matrix, theta1, theta2, theta3)

.getColumn(mat, column, vec)

.getColumns(mat, vec0, vec1, vec2, vec3)

.getElement(mat, row, column)

.getRow(mat, row, vec)

.getRows(mat, vec0, vec1, vec2, vec3)

.invert(mat, resultMat)

.lookAt(viewMatrix, eyePt, centerPt, worldUpVec)

.makeAxisAngleRotate(mat, angle, ax, ay, az)

.makeFrustum(mat, left, right, bottom, top, near, far)

.makeOrtho(mat, left, right, bottom, top, near, far)

.makePerspective(mat, fovy, aspect, near, far)

.makeScale(mat, x, y, z)

.makeTranslate(mat, x, y, z)

.multMat(mat0, mat1, resultMat)

.multVec3(mat, vec, resultVec)

.multVec3NoTranslate(mat, vec, resultVec)

.multVec3Projective(mat, vec, resultVec)

.multVec3ToArray(mat, vec, resultVec)

.multVec4(mat, vec, resultVec)

.multVec4ToArray(mat, vec, resultVec)

.scale(mat0, scalar, resultMat)

.setColumn(mat, column, vec)

.setColumnValues(mat, column, v0, v1, v2, v3)

.setColumns(mat, vec0, vec1, vec2, vec3)

.setDiagonal(mat, vec)

.setDiagonalValues(mat, v00, v11, v22, v33)

.setElement(mat, row, column, value)

.setFromArray(mat, values)

.setFromRowMajorArray(mat, values)

.setFromValues(mat, v00, v10, v20, v30, v01, v11, v21, v31, v02, v12, v22, v32, v03, v13, v23, v33)

.setIdentity(mat)

.setRow(mat, row, vec)

.setRowValues(mat, row, v0, v1, v2, v3)

.setRows(mat, vec0, vec1, vec2, vec3)

.setZero(mat)

.subtract(mat0, mat1, resultMat)

.toEulerZXZ(matrix, euler)

.toLookAt(viewMatrix, eyePt, fwdVec, worldUpVec)

.transpose(mat, resultMat)