Matrix4 (libGDX Core 1.6.1 API)

java.lang.Object
- com.badlogic.gdx.math.Matrix4

All Implemented Interfaces:

Serializable
```
public class Matrix4
extends Object
implements Serializable
```
Encapsulates a column major 4 by 4 matrix. Like the Vector3 class it allows the chaining of methods by returning a reference to itself. For example:
```
 Matrix4 mat = new Matrix4().trn(position).mul(camera.combined);
 
```
Author:

[email protected]

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`M00` XX: Typically the unrotated X component for scaling, also the cosine of the angle when rotated on the Y and/or Z axis.
`static int`	`M01` XY: Typically the negative sine of the angle when rotated on the Z axis.
`static int`	`M02` XZ: Typically the sine of the angle when rotated on the Y axis.
`static int`	`M03` XW: Typically the translation of the X component.
`static int`	`M10` YX: Typically the sine of the angle when rotated on the Z axis.
`static int`	`M11` YY: Typically the unrotated Y component for scaling, also the cosine of the angle when rotated on the X and/or Z axis.
`static int`	`M12` YZ: Typically the negative sine of the angle when rotated on the X axis.
`static int`	`M13` YW: Typically the translation of the Y component.
`static int`	`M20` ZX: Typically the negative sine of the angle when rotated on the Y axis.
`static int`	`M21` ZY: Typical the sine of the angle when rotated on the X axis.
`static int`	`M22` ZZ: Typically the unrotated Z component for scaling, also the cosine of the angle when rotated on the X and/or Y axis.
`static int`	`M23` ZW: Typically the translation of the Z component.
`static int`	`M30` WX: Typically the value zero.
`static int`	`M31` WY: Typically the value zero.
`static int`	`M32` WZ: Typically the value zero.
`static int`	`M33` WW: Typically the value one.
`float[]`	`val`

Constructor Summary

Constructors
Constructor and Description
`Matrix4()` Constructs an identity matrix
`Matrix4(float[] values)` Constructs a matrix from the given float array.
`Matrix4(Matrix4 matrix)` Constructs a matrix from the given matrix.
`Matrix4(Quaternion quaternion)` Constructs a rotation matrix from the given `Quaternion`.
`Matrix4(Vector3 position, Quaternion rotation, Vector3 scale)` Construct a matrix from the given translation, rotation and scale.

Method Summary

Methods
Modifier and Type	Method and Description
`Matrix4`	`avg(Matrix4[] t)` Averages the given transforms and stores the result in this matrix.
`Matrix4`	`avg(Matrix4[] t, float[] w)` Averages the given transforms with the given weights and stores the result in this matrix.
`Matrix4`	`avg(Matrix4 other, float w)` Averages the given transform with this one and stores the result in this matrix.
`Matrix4`	`cpy()`
`float`	`det()`
`static float`	`det(float[] values)` Computes the determinante of the given matrix.
`float`	`det3x3()`
`void`	`extract4x3Matrix(float[] dst)` Copies the 4x3 upper-left sub-matrix into float array.
`Quaternion`	`getRotation(Quaternion rotation)` Gets the rotation of this matrix.
`Quaternion`	`getRotation(Quaternion rotation, boolean normalizeAxes)` Gets the rotation of this matrix.
`Vector3`	`getScale(Vector3 scale)`
`float`	`getScaleX()`
`float`	`getScaleXSquared()`
`float`	`getScaleY()`
`float`	`getScaleYSquared()`
`float`	`getScaleZ()`
`float`	`getScaleZSquared()`
`Vector3`	`getTranslation(Vector3 position)`
`float[]`	`getValues()`
`Matrix4`	`idt()` Sets the matrix to an identity matrix.
`Matrix4`	`inv()` Inverts the matrix.
`static boolean`	`inv(float[] values)` Computes the inverse of the given matrix.
`Matrix4`	`lerp(Matrix4 matrix, float alpha)` Linearly interpolates between this matrix and the given matrix mixing by alpha
`static void`	`mul(float[] mata, float[] matb)` Multiplies the matrix mata with matrix matb, storing the result in mata.
`Matrix4`	`mul(Matrix4 matrix)` Postmultiplies this matrix with the given matrix, storing the result in this matrix.
`Matrix4`	`mulLeft(Matrix4 matrix)` Premultiplies this matrix with the given matrix, storing the result in this matrix.
`static void`	`mulVec(float[] mat, float[] vec)` Multiplies the vector with the given matrix.
`static void`	`mulVec(float[] mat, float[] vecs, int offset, int numVecs, int stride)` Multiplies the vectors with the given matrix.
`static void`	`prj(float[] mat, float[] vec)` Multiplies the vector with the given matrix, performing a division by w.
`static void`	`prj(float[] mat, float[] vecs, int offset, int numVecs, int stride)` Multiplies the vectors with the given matrix, , performing a division by w.
`static void`	`rot(float[] mat, float[] vec)` Multiplies the vector with the top most 3x3 sub-matrix of the given matrix.
`static void`	`rot(float[] mat, float[] vecs, int offset, int numVecs, int stride)` Multiplies the vectors with the top most 3x3 sub-matrix of the given matrix.
`Matrix4`	`rotate(float axisX, float axisY, float axisZ, float degrees)` Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4`	`rotate(Quaternion rotation)` Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4`	`rotate(Vector3 axis, float degrees)` Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4`	`rotate(Vector3 v1, Vector3 v2)` Postmultiplies this matrix by the rotation between two vectors.
`Matrix4`	`rotateRad(float axisX, float axisY, float axisZ, float radians)` Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4`	`rotateRad(Vector3 axis, float radians)` Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4`	`scale(float scaleX, float scaleY, float scaleZ)` Postmultiplies this matrix with a scale matrix.
`Matrix4`	`scl(float scale)`
`Matrix4`	`scl(float x, float y, float z)`
`Matrix4`	`scl(Vector3 scale)`
`Matrix4`	`set(Affine2 affine)` Sets this matrix to the given affine matrix.
`Matrix4`	`set(float[] values)` Sets the matrix to the given matrix as a float array.
`Matrix4`	`set(float quaternionX, float quaternionY, float quaternionZ, float quaternionW)` Sets the matrix to a rotation matrix representing the quaternion.
`Matrix4`	`set(float translationX, float translationY, float translationZ, float quaternionX, float quaternionY, float quaternionZ, float quaternionW)` Sets the matrix to a rotation matrix representing the translation and quaternion.
`Matrix4`	`set(float translationX, float translationY, float translationZ, float quaternionX, float quaternionY, float quaternionZ, float quaternionW, float scaleX, float scaleY, float scaleZ)` Sets the matrix to a rotation matrix representing the translation and quaternion.
`Matrix4`	`set(Matrix3 mat)` Sets this matrix to the given 3x3 matrix.
`Matrix4`	`set(Matrix4 matrix)` Sets the matrix to the given matrix.
`Matrix4`	`set(Quaternion quaternion)` Sets the matrix to a rotation matrix representing the quaternion.
`Matrix4`	`set(Vector3 position, Quaternion orientation)` Set this matrix to the specified translation and rotation.
`Matrix4`	`set(Vector3 position, Quaternion orientation, Vector3 scale)` Set this matrix to the specified translation, rotation and scale.
`Matrix4`	`set(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis, Vector3 pos)` Sets the four columns of the matrix which correspond to the x-, y- and z-axis of the vector space this matrix creates as well as the 4th column representing the translation of any point that is multiplied by this matrix.
`Matrix4`	`setAsAffine(Affine2 affine)` Assumes that this matrix is a 2D affine transformation, copying only the relevant components.
`Matrix4`	`setAsAffine(Matrix4 mat)` Assumes that both matrices are 2D affine transformations, copying only the relevant components.
`Matrix4`	`setFromEulerAngles(float yaw, float pitch, float roll)` Sets this matrix to a rotation matrix from the given euler angles.
`Matrix4`	`setToLookAt(Vector3 direction, Vector3 up)` Sets the matrix to a look at matrix with a direction and an up vector.
`Matrix4`	`setToLookAt(Vector3 position, Vector3 target, Vector3 up)` Sets this matrix to a look at matrix with the given position, target and up vector.
`Matrix4`	`setToOrtho(float left, float right, float bottom, float top, float near, float far)` Sets the matrix to an orthographic projection like glOrtho (http://www.opengl.org/sdk/docs/man/xhtml/glOrtho.xml) following the OpenGL equivalent
`Matrix4`	`setToOrtho2D(float x, float y, float width, float height)` Sets this matrix to an orthographic projection matrix with the origin at (x,y) extending by width and height.
`Matrix4`	`setToOrtho2D(float x, float y, float width, float height, float near, float far)` Sets this matrix to an orthographic projection matrix with the origin at (x,y) extending by width and height, having a near and far plane.
`Matrix4`	`setToProjection(float near, float far, float fovy, float aspectRatio)` Sets the matrix to a projection matrix with a near- and far plane, a field of view in degrees and an aspect ratio.
`Matrix4`	`setToProjection(float left, float right, float bottom, float top, float near, float far)` Sets the matrix to a projection matrix with a near/far plane, and left, bottom, right and top specifying the points on the near plane that are mapped to the lower left and upper right corners of the viewport.
`Matrix4`	`setToRotation(float axisX, float axisY, float axisZ, float degrees)` Sets the matrix to a rotation matrix around the given axis.
`Matrix4`	`setToRotation(float x1, float y1, float z1, float x2, float y2, float z2)` Set the matrix to a rotation matrix between two vectors.
`Matrix4`	`setToRotation(Vector3 axis, float degrees)` Sets the matrix to a rotation matrix around the given axis.
`Matrix4`	`setToRotation(Vector3 v1, Vector3 v2)` Set the matrix to a rotation matrix between two vectors.
`Matrix4`	`setToRotationRad(float axisX, float axisY, float axisZ, float radians)` Sets the matrix to a rotation matrix around the given axis.
`Matrix4`	`setToRotationRad(Vector3 axis, float radians)` Sets the matrix to a rotation matrix around the given axis.
`Matrix4`	`setToScaling(float x, float y, float z)` Sets this matrix to a scaling matrix
`Matrix4`	`setToScaling(Vector3 vector)` Sets this matrix to a scaling matrix
`Matrix4`	`setToTranslation(float x, float y, float z)` Sets this matrix to a translation matrix, overwriting it first by an identity matrix and then setting the 4th column to the translation vector.
`Matrix4`	`setToTranslation(Vector3 vector)` Sets this matrix to a translation matrix, overwriting it first by an identity matrix and then setting the 4th column to the translation vector.
`Matrix4`	`setToTranslationAndScaling(float translationX, float translationY, float translationZ, float scalingX, float scalingY, float scalingZ)` Sets this matrix to a translation and scaling matrix by first overwriting it with an identity and then setting the translation vector in the 4th column and the scaling vector in the diagonal.
`Matrix4`	`setToTranslationAndScaling(Vector3 translation, Vector3 scaling)` Sets this matrix to a translation and scaling matrix by first overwriting it with an identity and then setting the translation vector in the 4th column and the scaling vector in the diagonal.
`Matrix4`	`setToWorld(Vector3 position, Vector3 forward, Vector3 up)`
`Matrix4`	`setTranslation(float x, float y, float z)` Sets the 4th column to the translation vector.
`Matrix4`	`setTranslation(Vector3 vector)` Sets the 4th column to the translation vector.
`Matrix4`	`toNormalMatrix()` removes the translational part and transposes the matrix.
`String`	`toString()`
`Matrix4`	`tra()` Transposes the matrix.
`Matrix4`	`translate(float x, float y, float z)` Postmultiplies this matrix by a translation matrix.
`Matrix4`	`translate(Vector3 translation)` Postmultiplies this matrix by a translation matrix.
`Matrix4`	`trn(float x, float y, float z)` Adds a translational component to the matrix in the 4th column.
`Matrix4`	`trn(Vector3 vector)` Adds a translational component to the matrix in the 4th column.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - M00
```
public static final int M00
```
    XX: Typically the unrotated X component for scaling, also the cosine of the angle when rotated on the Y and/or Z axis. On Vector3 multiplication this value is multiplied with the source X component and added to the target X component.
    
    See Also:
    Constant Field Values
  - M01
```
public static final int M01
```
    XY: Typically the negative sine of the angle when rotated on the Z axis. On Vector3 multiplication this value is multiplied with the source Y component and added to the target X component.
    
    See Also:
    Constant Field Values
  - M02
```
public static final int M02
```
    XZ: Typically the sine of the angle when rotated on the Y axis. On Vector3 multiplication this value is multiplied with the source Z component and added to the target X component.
    
    See Also:
    Constant Field Values
  - M03
```
public static final int M03
```
    XW: Typically the translation of the X component. On Vector3 multiplication this value is added to the target X component.
    
    See Also:
    Constant Field Values
  - M10
```
public static final int M10
```
    YX: Typically the sine of the angle when rotated on the Z axis. On Vector3 multiplication this value is multiplied with the source X component and added to the target Y component.
    
    See Also:
    Constant Field Values
  - M11
```
public static final int M11
```
    YY: Typically the unrotated Y component for scaling, also the cosine of the angle when rotated on the X and/or Z axis. On Vector3 multiplication this value is multiplied with the source Y component and added to the target Y component.
    
    See Also:
    Constant Field Values
  - M12
```
public static final int M12
```
    YZ: Typically the negative sine of the angle when rotated on the X axis. On Vector3 multiplication this value is multiplied with the source Z component and added to the target Y component.
    
    See Also:
    Constant Field Values
  - M13
```
public static final int M13
```
    YW: Typically the translation of the Y component. On Vector3 multiplication this value is added to the target Y component.
    
    See Also:
    Constant Field Values
  - M20
```
public static final int M20
```
    ZX: Typically the negative sine of the angle when rotated on the Y axis. On Vector3 multiplication this value is multiplied with the source X component and added to the target Z component.
    
    See Also:
    Constant Field Values
  - M21
```
public static final int M21
```
    ZY: Typical the sine of the angle when rotated on the X axis. On Vector3 multiplication this value is multiplied with the source Y component and added to the target Z component.
    
    See Also:
    Constant Field Values
  - M22
```
public static final int M22
```
    ZZ: Typically the unrotated Z component for scaling, also the cosine of the angle when rotated on the X and/or Y axis. On Vector3 multiplication this value is multiplied with the source Z component and added to the target Z component.
    
    See Also:
    Constant Field Values
  - M23
```
public static final int M23
```
    ZW: Typically the translation of the Z component. On Vector3 multiplication this value is added to the target Z component.
    
    See Also:
    Constant Field Values
  - M30
```
public static final int M30
```
    WX: Typically the value zero. On Vector3 multiplication this value is ignored.
    
    See Also:
    Constant Field Values
  - M31
```
public static final int M31
```
    WY: Typically the value zero. On Vector3 multiplication this value is ignored.
    
    See Also:
    Constant Field Values
  - M32
```
public static final int M32
```
    WZ: Typically the value zero. On Vector3 multiplication this value is ignored.
    
    See Also:
    Constant Field Values
  - M33
```
public static final int M33
```
    WW: Typically the value one. On Vector3 multiplication this value is ignored.
    
    See Also:
    Constant Field Values
  - val
```
public final float[] val
```
- Constructor Detail
  - Matrix4
```
public Matrix4()
```
    Constructs an identity matrix
  - Matrix4
```
public Matrix4(Matrix4 matrix)
```
    Constructs a matrix from the given matrix.
    
    Parameters:
    matrix - The matrix to copy. (This matrix is not modified)
  - Matrix4
```
public Matrix4(float[] values)
```
    Constructs a matrix from the given float array. The array must have at least 16 elements; the first 16 will be copied.
    
    Parameters:
    values - The float array to copy. Remember that this matrix is in column major order. (The float array is not modified)
  - Matrix4
```
public Matrix4(Quaternion quaternion)
```
    Constructs a rotation matrix from the given Quaternion.
    
    Parameters:
    quaternion - The quaternion to be copied. (The quaternion is not modified)
  - Matrix4
```
public Matrix4(Vector3 position,
       Quaternion rotation,
       Vector3 scale)
```
    Construct a matrix from the given translation, rotation and scale.
    
    Parameters:
    position - The translation
    rotation - The rotation, must be normalized
    scale - The scale
- Method Detail
  - set
```
public Matrix4 set(Matrix4 matrix)
```
    Sets the matrix to the given matrix.
    
    Parameters:
    matrix - The matrix that is to be copied. (The given matrix is not modified)
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - set
```
public Matrix4 set(float[] values)
```
    Sets the matrix to the given matrix as a float array. The float array must have at least 16 elements; the first 16 will be copied.
    
    Parameters:
    values - The matrix, in float form, that is to be copied. Remember that this matrix is in column major order.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - set
```
public Matrix4 set(Quaternion quaternion)
```
    Sets the matrix to a rotation matrix representing the quaternion.
    
    Parameters:
    quaternion - The quaternion that is to be used to set this matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - set
```
public Matrix4 set(float quaternionX,
          float quaternionY,
          float quaternionZ,
          float quaternionW)
```
    Sets the matrix to a rotation matrix representing the quaternion.
    
    Parameters:
    quaternionX - The X component of the quaternion that is to be used to set this matrix.
    quaternionY - The Y component of the quaternion that is to be used to set this matrix.
    quaternionZ - The Z component of the quaternion that is to be used to set this matrix.
    quaternionW - The W component of the quaternion that is to be used to set this matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - set
```
public Matrix4 set(Vector3 position,
          Quaternion orientation)
```
    Set this matrix to the specified translation and rotation.
    
    Parameters:
    position - The translation
    orientation - The rotation, must be normalized
    
    Returns:
    This matrix for chaining
  - set
```
public Matrix4 set(float translationX,
          float translationY,
          float translationZ,
          float quaternionX,
          float quaternionY,
          float quaternionZ,
          float quaternionW)
```
    Sets the matrix to a rotation matrix representing the translation and quaternion.
    
    Parameters:
    translationX - The X component of the translation that is to be used to set this matrix.
    translationY - The Y component of the translation that is to be used to set this matrix.
    translationZ - The Z component of the translation that is to be used to set this matrix.
    quaternionX - The X component of the quaternion that is to be used to set this matrix.
    quaternionY - The Y component of the quaternion that is to be used to set this matrix.
    quaternionZ - The Z component of the quaternion that is to be used to set this matrix.
    quaternionW - The W component of the quaternion that is to be used to set this matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - set
```
public Matrix4 set(Vector3 position,
          Quaternion orientation,
          Vector3 scale)
```
    Set this matrix to the specified translation, rotation and scale.
    
    Parameters:
    position - The translation
    orientation - The rotation, must be normalized
    scale - The scale
    
    Returns:
    This matrix for chaining
  - set
```
public Matrix4 set(float translationX,
          float translationY,
          float translationZ,
          float quaternionX,
          float quaternionY,
          float quaternionZ,
          float quaternionW,
          float scaleX,
          float scaleY,
          float scaleZ)
```
    Sets the matrix to a rotation matrix representing the translation and quaternion.
    
    Parameters:
    translationX - The X component of the translation that is to be used to set this matrix.
    translationY - The Y component of the translation that is to be used to set this matrix.
    translationZ - The Z component of the translation that is to be used to set this matrix.
    quaternionX - The X component of the quaternion that is to be used to set this matrix.
    quaternionY - The Y component of the quaternion that is to be used to set this matrix.
    quaternionZ - The Z component of the quaternion that is to be used to set this matrix.
    quaternionW - The W component of the quaternion that is to be used to set this matrix.
    scaleX - The X component of the scaling that is to be used to set this matrix.
    scaleY - The Y component of the scaling that is to be used to set this matrix.
    scaleZ - The Z component of the scaling that is to be used to set this matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - set
```
public Matrix4 set(Vector3 xAxis,
          Vector3 yAxis,
          Vector3 zAxis,
          Vector3 pos)
```
    Sets the four columns of the matrix which correspond to the x-, y- and z-axis of the vector space this matrix creates as well as the 4th column representing the translation of any point that is multiplied by this matrix.
    
    Parameters:
    xAxis - The x-axis.
    yAxis - The y-axis.
    zAxis - The z-axis.
    pos - The translation vector.
  - cpy
```
public Matrix4 cpy()
```
    Returns:
    a copy of this matrix
  - trn
```
public Matrix4 trn(Vector3 vector)
```
    Adds a translational component to the matrix in the 4th column. The other columns are untouched.
    
    Parameters:
    vector - The translation vector to add to the current matrix. (This vector is not modified)
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - trn
```
public Matrix4 trn(float x,
          float y,
          float z)
```
    Adds a translational component to the matrix in the 4th column. The other columns are untouched.
    
    Parameters:
    x - The x-component of the translation vector.
    y - The y-component of the translation vector.
    z - The z-component of the translation vector.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - getValues
```
public float[] getValues()
```
    Returns:
    the backing float array
  - mul
```
public Matrix4 mul(Matrix4 matrix)
```
    Postmultiplies this matrix with the given matrix, storing the result in this matrix. For example:
```
 A.mul(B) results in A := AB.
 
```
    Parameters:
    matrix - The other matrix to multiply by.
    
    Returns:
    This matrix for the purpose of chaining operations together.
  - mulLeft
```
public Matrix4 mulLeft(Matrix4 matrix)
```
    Premultiplies this matrix with the given matrix, storing the result in this matrix. For example:
```
 A.mulLeft(B) results in A := BA.
 
```
    Parameters:
    matrix - The other matrix to multiply by.
    
    Returns:
    This matrix for the purpose of chaining operations together.
  - tra
```
public Matrix4 tra()
```
    Transposes the matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - idt
```
public Matrix4 idt()
```
    Sets the matrix to an identity matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - inv
```
public Matrix4 inv()
```
    Inverts the matrix. Stores the result in this matrix.
    
    Returns:
    This matrix for the purpose of chaining methods together.
    
    Throws:
    
    RuntimeException - if the matrix is singular (not invertible)
  - det
```
public float det()
```
    Returns:
    The determinant of this matrix
  - det3x3
```
public float det3x3()
```
    Returns:
    The determinant of the 3x3 upper left matrix
  - setToProjection
```
public Matrix4 setToProjection(float near,
                      float far,
                      float fovy,
                      float aspectRatio)
```
    Sets the matrix to a projection matrix with a near- and far plane, a field of view in degrees and an aspect ratio. Note that the field of view specified is the angle in degrees for the height, the field of view for the width will be calculated according to the aspect ratio.
    
    Parameters:
    near - The near plane
    far - The far plane
    fovy - The field of view of the height in degrees
    aspectRatio - The "width over height" aspect ratio
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToProjection
```
public Matrix4 setToProjection(float left,
                      float right,
                      float bottom,
                      float top,
                      float near,
                      float far)
```
    Sets the matrix to a projection matrix with a near/far plane, and left, bottom, right and top specifying the points on the near plane that are mapped to the lower left and upper right corners of the viewport. This allows to create projection matrix with off-center vanishing point.
    
    Parameters:
    left -
    right -
    bottom -
    top -
    near - The near plane
    far - The far plane
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToOrtho2D
```
public Matrix4 setToOrtho2D(float x,
                   float y,
                   float width,
                   float height)
```
    Sets this matrix to an orthographic projection matrix with the origin at (x,y) extending by width and height. The near plane is set to 0, the far plane is set to 1.
    
    Parameters:
    x - The x-coordinate of the origin
    y - The y-coordinate of the origin
    width - The width
    height - The height
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToOrtho2D
```
public Matrix4 setToOrtho2D(float x,
                   float y,
                   float width,
                   float height,
                   float near,
                   float far)
```
    Sets this matrix to an orthographic projection matrix with the origin at (x,y) extending by width and height, having a near and far plane.
    
    Parameters:
    x - The x-coordinate of the origin
    y - The y-coordinate of the origin
    width - The width
    height - The height
    near - The near plane
    far - The far plane
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToOrtho
```
public Matrix4 setToOrtho(float left,
                 float right,
                 float bottom,
                 float top,
                 float near,
                 float far)
```
    Sets the matrix to an orthographic projection like glOrtho (http://www.opengl.org/sdk/docs/man/xhtml/glOrtho.xml) following the OpenGL equivalent
    
    Parameters:
    left - The left clipping plane
    right - The right clipping plane
    bottom - The bottom clipping plane
    top - The top clipping plane
    near - The near clipping plane
    far - The far clipping plane
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setTranslation
```
public Matrix4 setTranslation(Vector3 vector)
```
    Sets the 4th column to the translation vector.
    
    Parameters:
    vector - The translation vector
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setTranslation
```
public Matrix4 setTranslation(float x,
                     float y,
                     float z)
```
    Sets the 4th column to the translation vector.
    
    Parameters:
    x - The X coordinate of the translation vector
    y - The Y coordinate of the translation vector
    z - The Z coordinate of the translation vector
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToTranslation
```
public Matrix4 setToTranslation(Vector3 vector)
```
    Sets this matrix to a translation matrix, overwriting it first by an identity matrix and then setting the 4th column to the translation vector.
    
    Parameters:
    vector - The translation vector
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToTranslation
```
public Matrix4 setToTranslation(float x,
                       float y,
                       float z)
```
    Sets this matrix to a translation matrix, overwriting it first by an identity matrix and then setting the 4th column to the translation vector.
    
    Parameters:
    x - The x-component of the translation vector.
    y - The y-component of the translation vector.
    z - The z-component of the translation vector.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToTranslationAndScaling
```
public Matrix4 setToTranslationAndScaling(Vector3 translation,
                                 Vector3 scaling)
```
    Sets this matrix to a translation and scaling matrix by first overwriting it with an identity and then setting the translation vector in the 4th column and the scaling vector in the diagonal.
    
    Parameters:
    translation - The translation vector
    scaling - The scaling vector
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToTranslationAndScaling
```
public Matrix4 setToTranslationAndScaling(float translationX,
                                 float translationY,
                                 float translationZ,
                                 float scalingX,
                                 float scalingY,
                                 float scalingZ)
```
    Sets this matrix to a translation and scaling matrix by first overwriting it with an identity and then setting the translation vector in the 4th column and the scaling vector in the diagonal.
    
    Parameters:
    translationX - The x-component of the translation vector
    translationY - The y-component of the translation vector
    translationZ - The z-component of the translation vector
    scalingX - The x-component of the scaling vector
    scalingY - The x-component of the scaling vector
    scalingZ - The x-component of the scaling vector
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToRotation
```
public Matrix4 setToRotation(Vector3 axis,
                    float degrees)
```
    Sets the matrix to a rotation matrix around the given axis.
    
    Parameters:
    axis - The axis
    degrees - The angle in degrees
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToRotationRad
```
public Matrix4 setToRotationRad(Vector3 axis,
                       float radians)
```
    Sets the matrix to a rotation matrix around the given axis.
    
    Parameters:
    axis - The axis
    radians - The angle in radians
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToRotation
```
public Matrix4 setToRotation(float axisX,
                    float axisY,
                    float axisZ,
                    float degrees)
```
    Sets the matrix to a rotation matrix around the given axis.
    
    Parameters:
    axisX - The x-component of the axis
    axisY - The y-component of the axis
    axisZ - The z-component of the axis
    degrees - The angle in degrees
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToRotationRad
```
public Matrix4 setToRotationRad(float axisX,
                       float axisY,
                       float axisZ,
                       float radians)
```
    Sets the matrix to a rotation matrix around the given axis.
    
    Parameters:
    axisX - The x-component of the axis
    axisY - The y-component of the axis
    axisZ - The z-component of the axis
    radians - The angle in radians
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToRotation
```
public Matrix4 setToRotation(Vector3 v1,
                    Vector3 v2)
```
    Set the matrix to a rotation matrix between two vectors.
    
    Parameters:
    v1 - The base vector
    v2 - The target vector
    
    Returns:
    This matrix for the purpose of chaining methods together
  - setToRotation
```
public Matrix4 setToRotation(float x1,
                    float y1,
                    float z1,
                    float x2,
                    float y2,
                    float z2)
```
    Set the matrix to a rotation matrix between two vectors.
    
    Parameters:
    x1 - The base vectors x value
    y1 - The base vectors y value
    z1 - The base vectors z value
    x2 - The target vector x value
    y2 - The target vector y value
    z2 - The target vector z value
    
    Returns:
    This matrix for the purpose of chaining methods together
  - setFromEulerAngles
```
public Matrix4 setFromEulerAngles(float yaw,
                         float pitch,
                         float roll)
```
    Sets this matrix to a rotation matrix from the given euler angles.
    
    Parameters:
    yaw - the yaw in degrees
    pitch - the pitch in degrees
    roll - the roll in degrees
    
    Returns:
    This matrix
  - setToScaling
```
public Matrix4 setToScaling(Vector3 vector)
```
    Sets this matrix to a scaling matrix
    
    Parameters:
    vector - The scaling vector
    
    Returns:
    This matrix for chaining.
  - setToScaling
```
public Matrix4 setToScaling(float x,
                   float y,
                   float z)
```
    Sets this matrix to a scaling matrix
    
    Parameters:
    x - The x-component of the scaling vector
    y - The y-component of the scaling vector
    z - The z-component of the scaling vector
    
    Returns:
    This matrix for chaining.
  - setToLookAt
```
public Matrix4 setToLookAt(Vector3 direction,
                  Vector3 up)
```
    Sets the matrix to a look at matrix with a direction and an up vector. Multiply with a translation matrix to get a camera model view matrix.
    
    Parameters:
    direction - The direction vector
    up - The up vector
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - setToLookAt
```
public Matrix4 setToLookAt(Vector3 position,
                  Vector3 target,
                  Vector3 up)
```
    Sets this matrix to a look at matrix with the given position, target and up vector.
    
    Parameters:
    position - the position
    target - the target
    up - the up vector
    
    Returns:
    This matrix
  - setToWorld
```
public Matrix4 setToWorld(Vector3 position,
                 Vector3 forward,
                 Vector3 up)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - lerp
```
public Matrix4 lerp(Matrix4 matrix,
           float alpha)
```
    Linearly interpolates between this matrix and the given matrix mixing by alpha
    
    Parameters:
    matrix - the matrix
    alpha - the alpha value in the range [0,1]
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - avg
```
public Matrix4 avg(Matrix4 other,
          float w)
```
    Averages the given transform with this one and stores the result in this matrix. Translations and scales are lerped while rotations are slerped.
    
    Parameters:
    other - The other transform
    w - Weight of this transform; weight of the other transform is (1 - w)
    
    Returns:
    This matrix for chaining
  - avg
```
public Matrix4 avg(Matrix4[] t)
```
    Averages the given transforms and stores the result in this matrix. Translations and scales are lerped while rotations are slerped. Does not destroy the data contained in t.
    
    Parameters:
    t - List of transforms
    
    Returns:
    This matrix for chaining
  - avg
```
public Matrix4 avg(Matrix4[] t,
          float[] w)
```
    Averages the given transforms with the given weights and stores the result in this matrix. Translations and scales are lerped while rotations are slerped. Does not destroy the data contained in t or w; Sum of w_i must be equal to 1, or unexpected results will occur.
    
    Parameters:
    t - List of transforms
    w - List of weights
    
    Returns:
    This matrix for chaining
  - set
```
public Matrix4 set(Matrix3 mat)
```
    Sets this matrix to the given 3x3 matrix. The third column of this matrix is set to (0,0,1,0).
    
    Parameters:
    mat - the matrix
  - set
```
public Matrix4 set(Affine2 affine)
```
    Sets this matrix to the given affine matrix. The values are mapped as follows:
```
      [  M00  M01   0   M02  ]
      [  M10  M11   0   M12  ]
      [   0    0    1    0   ]
      [   0    0    0    1   ]
 
```
    Parameters:
    affine - the affine matrix
    
    Returns:
    This matrix for chaining
  - setAsAffine
```
public Matrix4 setAsAffine(Affine2 affine)
```
    Assumes that this matrix is a 2D affine transformation, copying only the relevant components. The values are mapped as follows:
```
      [  M00  M01   _   M02  ]
      [  M10  M11   _   M12  ]
      [   _    _    _    _   ]
      [   _    _    _    _   ]
 
```
    Parameters:
    affine - the source matrix
    
    Returns:
    This matrix for chaining
  - setAsAffine
```
public Matrix4 setAsAffine(Matrix4 mat)
```
    Assumes that both matrices are 2D affine transformations, copying only the relevant components. The copied values are:
```
      [  M00  M01   _   M03  ]
      [  M10  M11   _   M13  ]
      [   _    _    _    _   ]
      [   _    _    _    _   ]
 
```
    Parameters:
    mat - the source matrix
    
    Returns:
    This matrix for chaining
  - scl
```
public Matrix4 scl(Vector3 scale)
```
  - scl
```
public Matrix4 scl(float x,
          float y,
          float z)
```
  - scl
```
public Matrix4 scl(float scale)
```
  - getTranslation
```
public Vector3 getTranslation(Vector3 position)
```
  - getRotation
```
public Quaternion getRotation(Quaternion rotation,
                     boolean normalizeAxes)
```
    Gets the rotation of this matrix.
    
    Parameters:
    rotation - The Quaternion to receive the rotation
    normalizeAxes - True to normalize the axes, necessary when the matrix might also include scaling.
    
    Returns:
    The provided Quaternion for chaining.
  - getRotation
```
public Quaternion getRotation(Quaternion rotation)
```
    Gets the rotation of this matrix.
    
    Parameters:
    rotation - The Quaternion to receive the rotation
    
    Returns:
    The provided Quaternion for chaining.
  - getScaleXSquared
```
public float getScaleXSquared()
```
    Returns:
    the squared scale factor on the X axis
  - getScaleYSquared
```
public float getScaleYSquared()
```
    Returns:
    the squared scale factor on the Y axis
  - getScaleZSquared
```
public float getScaleZSquared()
```
    Returns:
    the squared scale factor on the Z axis
  - getScaleX
```
public float getScaleX()
```
    Returns:
    the scale factor on the X axis (non-negative)
  - getScaleY
```
public float getScaleY()
```
    Returns:
    the scale factor on the Y axis (non-negative)
  - getScaleZ
```
public float getScaleZ()
```
    Returns:
    the scale factor on the X axis (non-negative)
  - getScale
```
public Vector3 getScale(Vector3 scale)
```
    Parameters:
    scale - The vector which will receive the (non-negative) scale components on each axis.
    
    Returns:
    The provided vector for chaining.
  - toNormalMatrix
```
public Matrix4 toNormalMatrix()
```
    removes the translational part and transposes the matrix.
  - mul
```
public static void mul(float[] mata,
       float[] matb)
```
    Multiplies the matrix mata with matrix matb, storing the result in mata. The arrays are assumed to hold 4x4 column major matrices as you can get from val. This is the same as mul(Matrix4).
    
    Parameters:
    mata - the first matrix.
    matb - the second matrix.
  - mulVec
```
public static void mulVec(float[] mat,
          float[] vec)
```
    Multiplies the vector with the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val. The vector array is assumed to hold a 3-component vector, with x being the first element, y being the second and z being the last component. The result is stored in the vector array. This is the same as Vector3.mul(Matrix4).
    
    Parameters:
    mat - the matrix
    vec - the vector.
  - mulVec
```
public static void mulVec(float[] mat,
          float[] vecs,
          int offset,
          int numVecs,
          int stride)
```
    Multiplies the vectors with the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val. The vectors array is assumed to hold 3-component vectors. Offset specifies the offset into the array where the x-component of the first vector is located. The numVecs parameter specifies the number of vectors stored in the vectors array. The stride parameter specifies the number of floats between subsequent vectors and must be >= 3. This is the same as Vector3.mul(Matrix4) applied to multiple vectors.
    
    Parameters:
    mat - the matrix
    vecs - the vectors
    offset - the offset into the vectors array
    numVecs - the number of vectors
    stride - the stride between vectors in floats
  - prj
```
public static void prj(float[] mat,
       float[] vec)
```
    Multiplies the vector with the given matrix, performing a division by w. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val. The vector array is assumed to hold a 3-component vector, with x being the first element, y being the second and z being the last component. The result is stored in the vector array. This is the same as Vector3.prj(Matrix4).
    
    Parameters:
    mat - the matrix
    vec - the vector.
  - prj
```
public static void prj(float[] mat,
       float[] vecs,
       int offset,
       int numVecs,
       int stride)
```
    Multiplies the vectors with the given matrix, , performing a division by w. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val. The vectors array is assumed to hold 3-component vectors. Offset specifies the offset into the array where the x-component of the first vector is located. The numVecs parameter specifies the number of vectors stored in the vectors array. The stride parameter specifies the number of floats between subsequent vectors and must be >= 3. This is the same as Vector3.prj(Matrix4) applied to multiple vectors.
    
    Parameters:
    mat - the matrix
    vecs - the vectors
    offset - the offset into the vectors array
    numVecs - the number of vectors
    stride - the stride between vectors in floats
  - rot
```
public static void rot(float[] mat,
       float[] vec)
```
    Multiplies the vector with the top most 3x3 sub-matrix of the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val. The vector array is assumed to hold a 3-component vector, with x being the first element, y being the second and z being the last component. The result is stored in the vector array. This is the same as Vector3.rot(Matrix4).
    
    Parameters:
    mat - the matrix
    vec - the vector.
  - rot
```
public static void rot(float[] mat,
       float[] vecs,
       int offset,
       int numVecs,
       int stride)
```
    Multiplies the vectors with the top most 3x3 sub-matrix of the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val. The vectors array is assumed to hold 3-component vectors. Offset specifies the offset into the array where the x-component of the first vector is located. The numVecs parameter specifies the number of vectors stored in the vectors array. The stride parameter specifies the number of floats between subsequent vectors and must be >= 3. This is the same as Vector3.rot(Matrix4) applied to multiple vectors.
    
    Parameters:
    mat - the matrix
    vecs - the vectors
    offset - the offset into the vectors array
    numVecs - the number of vectors
    stride - the stride between vectors in floats
  - inv
```
public static boolean inv(float[] values)
```
    Computes the inverse of the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val.
    
    Parameters:
    values - the matrix values.
    
    Returns:
    false in case the inverse could not be calculated, true otherwise.
  - det
```
public static float det(float[] values)
```
    Computes the determinante of the given matrix. The matrix array is assumed to hold a 4x4 column major matrix as you can get from val.
    
    Parameters:
    values - the matrix values.
    
    Returns:
    the determinante.
  - translate
```
public Matrix4 translate(Vector3 translation)
```
    Postmultiplies this matrix by a translation matrix. Postmultiplication is also used by OpenGL ES' glTranslate/glRotate/glScale
    
    Parameters:
    translation -
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - translate
```
public Matrix4 translate(float x,
                float y,
                float z)
```
    Postmultiplies this matrix by a translation matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale.
    
    Parameters:
    x - Translation in the x-axis.
    y - Translation in the y-axis.
    z - Translation in the z-axis.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - rotate
```
public Matrix4 rotate(Vector3 axis,
             float degrees)
```
    Postmultiplies this matrix with a (counter-clockwise) rotation matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale.
    
    Parameters:
    axis - The vector axis to rotate around.
    degrees - The angle in degrees.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - rotateRad
```
public Matrix4 rotateRad(Vector3 axis,
                float radians)
```
    Postmultiplies this matrix with a (counter-clockwise) rotation matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale.
    
    Parameters:
    axis - The vector axis to rotate around.
    radians - The angle in radians.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - rotate
```
public Matrix4 rotate(float axisX,
             float axisY,
             float axisZ,
             float degrees)
```
    Postmultiplies this matrix with a (counter-clockwise) rotation matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale
    
    Parameters:
    axisX - The x-axis component of the vector to rotate around.
    axisY - The y-axis component of the vector to rotate around.
    axisZ - The z-axis component of the vector to rotate around.
    degrees - The angle in degrees
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - rotateRad
```
public Matrix4 rotateRad(float axisX,
                float axisY,
                float axisZ,
                float radians)
```
    Postmultiplies this matrix with a (counter-clockwise) rotation matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale
    
    Parameters:
    axisX - The x-axis component of the vector to rotate around.
    axisY - The y-axis component of the vector to rotate around.
    axisZ - The z-axis component of the vector to rotate around.
    radians - The angle in radians
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - rotate
```
public Matrix4 rotate(Quaternion rotation)
```
    Postmultiplies this matrix with a (counter-clockwise) rotation matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale.
    
    Parameters:
    rotation -
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - rotate
```
public Matrix4 rotate(Vector3 v1,
             Vector3 v2)
```
    Postmultiplies this matrix by the rotation between two vectors.
    
    Parameters:
    v1 - The base vector
    v2 - The target vector
    
    Returns:
    This matrix for the purpose of chaining methods together
  - scale
```
public Matrix4 scale(float scaleX,
            float scaleY,
            float scaleZ)
```
    Postmultiplies this matrix with a scale matrix. Postmultiplication is also used by OpenGL ES' 1.x glTranslate/glRotate/glScale.
    
    Parameters:
    scaleX - The scale in the x-axis.
    scaleY - The scale in the y-axis.
    scaleZ - The scale in the z-axis.
    
    Returns:
    This matrix for the purpose of chaining methods together.
  - extract4x3Matrix
```
public void extract4x3Matrix(float[] dst)
```
    Copies the 4x3 upper-left sub-matrix into float array. The destination array is supposed to be a column major matrix.
    
    Parameters:
    dst - the destination matrix

Class Matrix4

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

M00

M01

M02

M03

M10

M11

M12

M13

M20

M21

M22

M23

M30

M31

M32

M33

val

Constructor Detail

Matrix4

Matrix4

Matrix4

Matrix4

Matrix4

Method Detail

set

set

set

set

set

set

set

set

set

cpy

trn

trn

getValues

mul

mulLeft

tra

idt

inv

det

det3x3

setToProjection

setToProjection

setToOrtho2D

setToOrtho2D

setToOrtho

setTranslation

setTranslation

setToTranslation

setToTranslation

setToTranslationAndScaling

setToTranslationAndScaling

setToRotation

setToRotationRad

setToRotation

setToRotationRad

setToRotation

setToRotation

setFromEulerAngles

setToScaling

setToScaling

setToLookAt

setToLookAt

setToWorld

toString

lerp

avg

avg

avg

set

set