A class representing a 4x4 [link:https://en.wikipedia.org/wiki/Matrix_(mathematics) matrix].

The most common use of a 4x4 matrix in 3D computer graphics is as a
[link:https://en.wikipedia.org/wiki/Transformation_matrix Transformation Matrix].
For an introduction to transformation matrices as used in WebGL, check out
[link:http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices this tutorial].

This allows a [page:Vector3] representing a point in 3D space to undergo transformations
such as translation, rotation, shear, scale, reflection, orthogonal or perspective projection
and so on, by being multiplied by the matrix. This is known as *applying*
the matrix to the vector.

Every [page:Object3D] has three associated Matrix4s:

- [page:Object3D.matrix]: This stores the local transform of the object. This is the object's transformation relative to its parent.
- [page:Object3D.matrixWorld]: The global or world transform of the object. If the object has no parent, then this is identical to the local transform stored in [page:Object3D.matrix matrix].
- [page:Object3D.modelViewMatrix]: This represents the object's transformation relative to the camera's coordinate system. An object's modelViewMatrix is the object's matrixWorld pre-multiplied by the camera's matrixWorldInverse.

- [page:Camera.matrixWorldInverse]: The view matrix - the inverse of the Camera's [page:Object3D.matrixWorld matrixWorld].
- [page:Camera.projectionMatrix]: Represents the information how to project the scene to clip space.

The [page:set]() method takes arguments in [link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order row-major]
order, while internally they are stored in the [page:.elements elements] array in column-major order.

This means that calling
```
const m = new THREE.Matrix4();
m.set( 11, 12, 13, 14,
21, 22, 23, 24,
31, 32, 33, 34,
41, 42, 43, 44 );
```

will result in the [page:.elements elements] array containing:
```
m.elements = [ 11, 21, 31, 41,
12, 22, 32, 42,
13, 23, 33, 43,
14, 24, 34, 44 ];
```

and internally all calculations are performed using column-major ordering. However, as the actual ordering
makes no difference mathematically and most people are used to thinking about matrices in row-major order,
the three.js documentation shows matrices in row-major order. Just bear in mind that if you are reading the source
code, you'll have to take the [link:https://en.wikipedia.org/wiki/Transpose transpose] of any matrices outlined here to make sense of the calculations.

There are several options available for extracting position, rotation and scale from a Matrix4.

- [page:Vector3.setFromMatrixPosition]: can be used to extract the translation component.
- [page:Vector3.setFromMatrixScale]: can be used to extract the scale component.
- [page:Quaternion.setFromRotationMatrix], [page:Euler.setFromRotationMatrix] or [page:.extractRotation extractRotation] can be used to extract the rotation component from a pure (unscaled) matrix.
- [page:.decompose decompose] can be used to extract position, rotation and scale all at once.

Creates and initializes the [name] to the 4x4 [link:https://en.wikipedia.org/wiki/Identity_matrix identity matrix].

A [link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major] list of matrix values.

Creates a new Matrix4 with identical [page:.elements elements] to this one.

Sets this matrix to the transformation composed of [page:Vector3 position], [page:Quaternion quaternion] and [page:Vector3 scale].

Copies the [page:.elements elements] of matrix [page:Matrix4 m] into this matrix.

Copies the translation component of the supplied matrix [page:Matrix4 m] into this matrix's translation component.

Decomposes this matrix into it's [page:Vector3 position], [page:Quaternion quaternion] and [page:Vector3 scale] components. The method can't be used to decompose an object's world matrix if its parent has a non-uniform scale.

Computes and returns the
[link:https://en.wikipedia.org/wiki/Determinant determinant] of this matrix.

Based on the method outlined [link:http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm here].

Return true if this matrix and [page:Matrix4 m] are equal.

Extracts the [link:https://en.wikipedia.org/wiki/Basis_(linear_algebra) basis] of this
matrix into the three axis vectors provided. If this matrix is:
```
a, b, c, d,
e, f, g, h,
i, j, k, l,
m, n, o, p
```

then the [page:Vector3 xAxis], [page:Vector3 yAxis], [page:Vector3 zAxis] will be set to:
```
xAxis = (a, e, i)
yAxis = (b, f, j)
zAxis = (c, g, k)
```

Extracts the rotation component of the supplied matrix [page:Matrix4 m] into this matrix's rotation component.

[page:Array array] - the array to read the elements from.

[page:Integer offset] - ( optional ) offset into the array. Default is 0.

Sets the elements of this matrix based on an [page:Array array] in
[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major] format.

Inverts this matrix, using the [link:https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution analytic method]. You can not invert with a determinant of zero. If you attempt this, the method produces a zero matrix instead.

Gets the maximum scale value of the 3 axes.

Resets this matrix to the [link:https://en.wikipedia.org/wiki/Identity_matrix identity matrix].

Constructs a rotation matrix, looking from [page:Vector3 eye] towards [page:Vector3 center] oriented by the [page:Vector3 up] vector.

[page:Vector3 axis] — Rotation axis, should be normalized.

[page:Float theta] — Rotation angle in radians.

Sets this matrix as rotation transform around [page:Vector3 axis] by [page:Float theta] radians.

This is a somewhat controversial but mathematically sound alternative to rotating via [page:Quaternions].
See the discussion [link:https://www.gamedev.net/articles/programming/math-and-physics/do-we-really-need-quaternions-r1199 here].

Set this to the [link:https://en.wikipedia.org/wiki/Basis_(linear_algebra) basis] matrix consisting
of the three provided basis vectors:
```
xAxis.x, yAxis.x, zAxis.x, 0,
xAxis.y, yAxis.y, zAxis.y, 0,
xAxis.z, yAxis.z, zAxis.z, 0,
0, 0, 0, 1
```

Creates a [link:https://en.wikipedia.org/wiki/3D_projection#Perspective_projection perspective projection] matrix. This is used internally by [page:PerspectiveCamera.updateProjectionMatrix]()

Creates an [link:https://en.wikipedia.org/wiki/Orthographic_projection orthographic projection] matrix. This is used internally by [page:OrthographicCamera.updateProjectionMatrix]().

Sets the rotation component (the upper left 3x3 matrix) of this matrix to the rotation specified by the given [page:Euler Euler Angle]. The rest of the matrix is set to the identity. Depending on the [page:Euler.order order] of the [page:Euler euler], there are six possible outcomes. See [link:https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix this page] for a complete list.

Sets the rotation component of this matrix to the rotation specified by [page:Quaternion q], as outlined
[link:https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion here].
The rest of the matrix is set to the identity. So, given [page:Quaternion q] = w + xi + yj + zk, the resulting matrix will be:
```
1-2y²-2z² 2xy-2zw 2xz+2yw 0
2xy+2zw 1-2x²-2z² 2yz-2xw 0
2xz-2yw 2yz+2xw 1-2x²-2y² 0
0 0 0 1
```

[page:Float theta] — Rotation angle in radians.

Sets this matrix as a rotational transformation around the X axis by [page:Float theta] (θ) radians.
The resulting matrix will be:
```
1 0 0 0
0 cos(θ) -sin(θ) 0
0 sin(θ) cos(θ) 0
0 0 0 1
```

[page:Float theta] — Rotation angle in radians.

Sets this matrix as a rotational transformation around the Y axis by [page:Float theta] (θ) radians.
The resulting matrix will be:
```
cos(θ) 0 sin(θ) 0
0 1 0 0
-sin(θ) 0 cos(θ) 0
0 0 0 1
```

[page:Float theta] — Rotation angle in radians.

Sets this matrix as a rotational transformation around the Z axis by [page:Float theta] (θ) radians.
The resulting matrix will be:
```
cos(θ) -sin(θ) 0 0
sin(θ) cos(θ) 0 0
0 0 1 0
0 0 0 1
```

[page:Float x] - the amount to scale in the X axis.

[page:Float y] - the amount to scale in the Y axis.

[page:Float z] - the amount to scale in the Z axis.

Sets this matrix as scale transform:
```
x, 0, 0, 0,
0, y, 0, 0,
0, 0, z, 0,
0, 0, 0, 1
```

[page:Float x] - the amount to shear in the X axis.

[page:Float y] - the amount to shear in the Y axis.

[page:Float z] - the amount to shear in the Z axis.

Sets this matrix as a shear transform:
```
1, y, z, 0,
x, 1, z, 0,
x, y, 1, 0,
0, 0, 0, 1
```

[page:Float x] - the amount to translate in the X axis.

[page:Float y] - the amount to translate in the Y axis.

[page:Float z] - the amount to translate in the Z axis.

Sets this matrix as a translation transform:
```
1, 0, 0, x,
0, 1, 0, y,
0, 0, 1, z,
0, 0, 0, 1
```

Post-multiplies this matrix by [page:Matrix4 m].

Sets this matrix to [page:Matrix4 a] x [page:Matrix4 b].

Multiplies every component of the matrix by a scalar value [page:Float s].

Pre-multiplies this matrix by [page:Matrix4 m].

Multiplies the columns of this matrix by vector [page:Vector3 v].

Set the [page:.elements elements] of this matrix to the supplied row-major values [page:Float n11], [page:Float n12], ... [page:Float n44].

Sets the position component for this matrix from vector [page:Vector3 v], without affecting the
rest of the matrix - i.e. if the matrix is currently:
```
a, b, c, d,
e, f, g, h,
i, j, k, l,
m, n, o, p
```

This becomes:
```
a, b, c, v.x,
e, f, g, v.y,
i, j, k, v.z,
m, n, o, p
```

[page:Array array] - (optional) array to store the resulting vector in.

[page:Integer offset] - (optional) offset in the array at which to put the result.

Writes the elements of this matrix to an array in
[link:https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order column-major] format.

[link:https://en.wikipedia.org/wiki/Transpose Transposes] this matrix.

[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]