java.lang.Object
- gaia.cu9.ari.gaiaorbit.util.math.Matrix4d

All Implemented Interfaces:

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

Serialized Form

Field Summary

Fields
Modifier and Type	Field	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.
`static double[]`	`stmp`
`double[]`	`tmp`
`double[]`	`val`

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Vector3d`	`addTranslationTo(Vector3d position)`
`Matrix4d`	`cpy()`
`double`	`det()`
`double`	`det3x3()`
`void`	`extract4x3Matrix(double[] dst)`	Copies the 4x3 upper-left sub-matrix into double array.
`Vector3d`	`getScale(Vector3d scale)`
`double`	`getScaleX()`
`double`	`getScaleXSquared()`
`double`	`getScaleY()`
`double`	`getScaleYSquared()`
`double`	`getScaleZ()`
`double`	`getScaleZSquared()`
`double[]`	`getTranslation()`
`Vector3d`	`getTranslation(Vector3d position)`
`float[]`	`getTranslationf()`
`void`	`getTranslationf(float[] vec)`
`com.badlogic.gdx.math.Vector3`	`getTranslationf(com.badlogic.gdx.math.Vector3 position)`
`double[]`	`getValues()`
`Matrix4d`	`idt()`	Sets the matrix to an identity matrix.
`Matrix4d`	`inv()`
`static boolean`	`inv(double[] values)`	Computes the inverse of the given matrix.
`Matrix4d`	`lerp(Matrix4d matrix, double alpha)`	Linearly interpolates between this matrix and the given matrix mixing by alpha
`static void`	`mul(double[] mata, double[] matb)`	Multiplies the matrix mata with matrix matb, storing the result in mata.
`Matrix4d`	`mul(Matrix4d matrix)`	Postmultiplies this matrix with the given matrix, storing the result in this matrix.
`Matrix4d`	`mulLeft(Matrix4d matrix)`	Premultiplies this matrix with the given matrix, storing the result in this matrix.
`static void`	`prj(double[] mat, double[] vec)`	Multiplies the vector with the given matrix, performing a division by w.
`static void`	`prj(double[] mat, double[] vecs, int offset, int numVecs, int stride)`	Multiplies the vectors with the given matrix, , performing a division by w.
`com.badlogic.gdx.math.Matrix4`	`putIn(com.badlogic.gdx.math.Matrix4 aux)`	Sets the given matrix to this matrix
`Matrix4d`	`rotate(double axisX, double axisY, double axisZ, double degrees)`	Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4d`	`rotate(Quaterniond rotation)`	Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4d`	`rotate(Vector3d axis, double degrees)`	Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4d`	`rotate(Vector3d v1, Vector3d v2)`	Postmultiplies this matrix by the rotation between two vectors.
`Matrix4d`	`rotateRad(double axisX, double axisY, double axisZ, double radians)`	Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4d`	`rotateRad(Vector3d axis, double radians)`	Postmultiplies this matrix with a (counter-clockwise) rotation matrix.
`Matrix4d`	`scale(double scaleX, double scaleY, double scaleZ)`	Postmultiplies this matrix with a scale matrix.
`Matrix4d`	`scl(double scale)`
`Matrix4d`	`scl(double x, double y, double z)`
`Matrix4d`	`scl(Vector3d scale)`
`Matrix4d`	`set(double[] values)`	Sets the matrix to the given matrix as a double array.
`Matrix4d`	`set(double quaternionX, double quaternionY, double quaternionZ, double quaternionW)`	Sets the matrix to a rotation matrix representing the quaternion.
`Matrix4d`	`set(double translationX, double translationY, double translationZ, double quaternionX, double quaternionY, double quaternionZ, double quaternionW)`	Sets the matrix to a rotation matrix representing the translation and quaternion.
`Matrix4d`	`set(double translationX, double translationY, double translationZ, double quaternionX, double quaternionY, double quaternionZ, double quaternionW, double scaleX, double scaleY, double scaleZ)`	Sets the matrix to a rotation matrix representing the translation and quaternion.
`Matrix4d`	`set(float[] values)`
`Matrix4d`	`set(com.badlogic.gdx.math.Matrix3 mat)`	Sets this matrix to the given 3x3 matrix.
`Matrix4d`	`set(Matrix4d matrix)`	Sets the matrix to the given matrix.
`Matrix4d`	`set(Quaterniond quaternion)`	Sets the matrix to a rotation matrix representing the quaternion.
`Matrix4d`	`set(Vector3d position, Quaterniond orientation)`	Set this matrix to the specified translation and rotation.
`Matrix4d`	`set(Vector3d position, Quaterniond orientation, Vector3d scale)`	Set this matrix to the specified translation, rotation and scale.
`Matrix4d`	`set(Vector3d xAxis, Vector3d yAxis, Vector3d zAxis, Vector3d 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.
`Matrix4d`	`setFromEulerAngles(double yaw, double pitch, double roll)`	Sets this matrix to a rotation matrix from the given euler angles.
`Matrix4d`	`setToLookAt(Vector3d direction, Vector3d up)`	Sets the matrix to a look at matrix with a direction and an up vector.
`Matrix4d`	`setToLookAt(Vector3d position, Vector3d target, Vector3d up)`	Sets this matrix to a look at matrix with the given position, target and up vector.
`Matrix4d`	`setToOrtho(double left, double right, double bottom, double top, double near, double far)`	Sets the matrix to an orthographic projection like glOrtho (http://www.opengl.org/sdk/docs/man/xhtml/glOrtho.xml) following the OpenGL equivalent
`Matrix4d`	`setToOrtho2D(double x, double y, double width, double height)`	Sets this matrix to an orthographic projection matrix with the origin at (x,y) extending by width and height.
`Matrix4d`	`setToOrtho2D(double x, double y, double width, double height, double near, double 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.
`Matrix4d`	`setToProjection(double near, double far, double fov, double aspectRatio)`	Sets the matrix to a projection matrix with a near- and far plane, a field of view in degrees and an aspect ratio.
`Matrix4d`	`setToRotation(double axisX, double axisY, double axisZ, double degrees)`	Sets the matrix to a rotation matrix around the given axis.
`Matrix4d`	`setToRotation(double x1, double y1, double z1, double x2, double y2, double z2)`	Set the matrix to a rotation matrix between two vectors.
`Matrix4d`	`setToRotation(Vector3d axis, double degrees)`	Sets the matrix to a rotation matrix around the given axis.
`Matrix4d`	`setToRotation(Vector3d v1, Vector3d v2)`	Set the matrix to a rotation matrix between two vectors.
`Matrix4d`	`setToRotationRad(double axisX, double axisY, double axisZ, double radians)`	Sets the matrix to a rotation matrix around the given axis.
`Matrix4d`	`setToRotationRad(Vector3d axis, double radians)`	Sets the matrix to a rotation matrix around the given axis.
`Matrix4d`	`setToScaling(double x, double y, double z)`	Sets this matrix to a scaling matrix
`Matrix4d`	`setToScaling(Vector3d vector)`	Sets this matrix to a scaling matrix
`Matrix4d`	`setToTranslation(double x, double y, double 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.
`Matrix4d`	`setToTranslation(com.badlogic.gdx.math.Vector3 vector)`
`Matrix4d`	`setToTranslation(Vector3d 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.
`Matrix4d`	`setToTranslationAndScaling(double translationX, double translationY, double translationZ, double scalingX, double scalingY, double 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.
`Matrix4d`	`setToTranslationAndScaling(Vector3d translation, Vector3d 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.
`Matrix4d`	`setToWorld(Vector3d position, Vector3d forward, Vector3d up)`
`Matrix4d`	`setTranslation(double x, double y, double z)`	Sets the 4th column to the translation vector.
`Matrix4d`	`setTranslation(Vector3d vector)`	Sets the 4th column to the translation vector.
`Matrix4d`	`toNormalMatrix()`	removes the translational part and transposes the matrix.
`java.lang.String`	`toString()`
`Matrix4d`	`tra()`	Transposes the matrix.
`Matrix4d`	`translate(double[] translation)`	Postmultiplies this matrix by a translation matrix.
`Matrix4d`	`translate(double x, double y, double z)`	Postmultiplies this matrix by a translation matrix.
`Matrix4d`	`translate(Vector3d translation)`	Postmultiplies this matrix by a translation matrix.
`Matrix4d`	`trn(double x, double y, double z)`	Adds a translational component to the matrix in the 4th column.
`Matrix4d`	`trn(Vector3d vector)`	Adds a translational component to the matrix in the 4th column.

Methods inherited from class java.lang.Object
clone, equals, finalize, 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d 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 Vector3d multiplication this value is ignored.
    
    See Also:
    
    Constant Field Values
  - M31
```
public static final int M31
```
    WY: Typically the value zero. On Vector3d multiplication this value is ignored.
    
    See Also:
    
    Constant Field Values
  - M32
```
public static final int M32
```
    WZ: Typically the value zero. On Vector3d multiplication this value is ignored.
    
    See Also:
    
    Constant Field Values
  - M33
```
public static final int M33
```
    WW: Typically the value one. On Vector3d multiplication this value is ignored.
    
    See Also:
    
    Constant Field Values
  - stmp
```
public static final double[] stmp
```
  - tmp
```
public final double[] tmp
```
  - val
```
public final double[] val
```
- Constructor Detail
  - Matrix4d
```
public Matrix4d()
```
    Constructs an identity matrix
  - Matrix4d
```
public Matrix4d(Matrix4d matrix)
```
    Constructs a matrix from the given matrix.
    
    Parameters:
    
    matrix - The matrix to copy. (This matrix is not modified)
  - Matrix4d
```
public Matrix4d(double[] values)
```
    Constructs a matrix from the given double array. The array must have at least 16 elements; the first 16 will be copied.
    
    Parameters:
    
    values - The double array to copy. Remember that this matrix is in column major order. (The double array is not modified.)
  - Matrix4d
```
public Matrix4d(float[] values)
```
  - Matrix4d
```
public Matrix4d(Quaterniond quaternion)
```
    Constructs a rotation matrix from the given Quaterniond.
    
    Parameters:
    
    quaternion - The quaternion to be copied. (The quaternion is not modified)
  - Matrix4d
```
public Matrix4d(Vector3d position,
                Quaterniond rotation,
                Vector3d 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 Matrix4d set(Matrix4d 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 Matrix4d set(double[] values)
```
    Sets the matrix to the given matrix as a double array. The double array must have at least 16 elements; the first 16 will be copied.
    
    Parameters:
    
    values - The matrix, in double 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 Matrix4d set(float[] values)
```
  - set
```
public Matrix4d set(Quaterniond 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 Matrix4d set(double quaternionX,
                    double quaternionY,
                    double quaternionZ,
                    double 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 Matrix4d set(Vector3d position,
                    Quaterniond 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 Matrix4d set(double translationX,
                    double translationY,
                    double translationZ,
                    double quaternionX,
                    double quaternionY,
                    double quaternionZ,
                    double 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 Matrix4d set(Vector3d position,
                    Quaterniond orientation,
                    Vector3d 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 Matrix4d set(double translationX,
                    double translationY,
                    double translationZ,
                    double quaternionX,
                    double quaternionY,
                    double quaternionZ,
                    double quaternionW,
                    double scaleX,
                    double scaleY,
                    double 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 Matrix4d set(Vector3d xAxis,
                    Vector3d yAxis,
                    Vector3d zAxis,
                    Vector3d 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 Matrix4d cpy()
```
    Returns:
    
    a copy of this matrix
  - trn
```
public Matrix4d trn(Vector3d 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 Matrix4d trn(double x,
                    double y,
                    double 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 double[] getValues()
```
    Returns:
    
    the backing double array
  - mul
```
public Matrix4d mul(Matrix4d 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 Matrix4d mulLeft(Matrix4d 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 Matrix4d tra()
```
    Transposes the matrix.
    
    Returns:
    
    This matrix for the purpose of chaining methods together.
  - idt
```
public Matrix4d idt()
```
    Sets the matrix to an identity matrix.
    
    Returns:
    
    This matrix for the purpose of chaining methods together.
  - inv
```
public Matrix4d inv()
```
  - inv
```
public static boolean inv(double[] 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 Matrix4.val.
    
    Parameters:
    
    values - the matrix values.
    
    Returns:
    
    false in case the inverse could not be calculated, true otherwise.
  - det
```
public double det()
```
    Returns:
    
    The determinant of this matrix
  - det3x3
```
public double det3x3()
```
    Returns:
    
    The determinant of the 3x3 upper left matrix
  - setToProjection
```
public Matrix4d setToProjection(double near,
                                double far,
                                double fov,
                                double aspectRatio)
```
    Sets the matrix to a projection matrix with a near- and far plane, a field of view in degrees and an aspect ratio.
    
    Parameters:
    
    near - The near plane
    
    far - The far plane
    
    fov - The field of view in degrees
    
    aspectRatio - The "width over height" aspect ratio
    
    Returns:
    
    This matrix for the purpose of chaining methods together.
  - setToOrtho2D
```
public Matrix4d setToOrtho2D(double x,
                             double y,
                             double width,
                             double 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 Matrix4d setToOrtho2D(double x,
                             double y,
                             double width,
                             double height,
                             double near,
                             double 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 Matrix4d setToOrtho(double left,
                           double right,
                           double bottom,
                           double top,
                           double near,
                           double 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 Matrix4d setTranslation(Vector3d 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 Matrix4d setTranslation(double x,
                               double y,
                               double 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 Matrix4d setToTranslation(Vector3d 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 Matrix4d setToTranslation(com.badlogic.gdx.math.Vector3 vector)
```
  - setToTranslation
```
public Matrix4d setToTranslation(double x,
                                 double y,
                                 double 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 Matrix4d setToTranslationAndScaling(Vector3d translation,
                                           Vector3d 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 Matrix4d setToTranslationAndScaling(double translationX,
                                           double translationY,
                                           double translationZ,
                                           double scalingX,
                                           double scalingY,
                                           double 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 Matrix4d setToRotation(Vector3d axis,
                              double 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 Matrix4d setToRotationRad(Vector3d axis,
                                 double 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 Matrix4d setToRotation(double axisX,
                              double axisY,
                              double axisZ,
                              double 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 Matrix4d setToRotationRad(double axisX,
                                 double axisY,
                                 double axisZ,
                                 double 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 Matrix4d setToRotation(Vector3d v1,
                              Vector3d 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 Matrix4d setToRotation(double x1,
                              double y1,
                              double z1,
                              double x2,
                              double y2,
                              double 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 Matrix4d setFromEulerAngles(double yaw,
                                   double pitch,
                                   double 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 Matrix4d setToScaling(Vector3d vector)
```
    Sets this matrix to a scaling matrix
    
    Parameters:
    
    vector - The scaling vector
    
    Returns:
    
    This matrix for chaining.
  - setToScaling
```
public Matrix4d setToScaling(double x,
                             double y,
                             double 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 Matrix4d setToLookAt(Vector3d direction,
                            Vector3d 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 Matrix4d setToLookAt(Vector3d position,
                            Vector3d target,
                            Vector3d 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 Matrix4d setToWorld(Vector3d position,
                           Vector3d forward,
                           Vector3d up)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - lerp
```
public Matrix4d lerp(Matrix4d matrix,
                     double 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.
  - set
```
public Matrix4d set(com.badlogic.gdx.math.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
  - scl
```
public Matrix4d scl(Vector3d scale)
```
  - scl
```
public Matrix4d scl(double x,
                    double y,
                    double z)
```
  - scl
```
public Matrix4d scl(double scale)
```
  - getTranslation
```
public Vector3d getTranslation(Vector3d position)
```
  - getTranslationf
```
public com.badlogic.gdx.math.Vector3 getTranslationf(com.badlogic.gdx.math.Vector3 position)
```
  - getTranslation
```
public double[] getTranslation()
```
  - getTranslationf
```
public float[] getTranslationf()
```
  - getTranslationf
```
public void getTranslationf(float[] vec)
```
  - addTranslationTo
```
public Vector3d addTranslationTo(Vector3d position)
```
  - getScaleXSquared
```
public double getScaleXSquared()
```
    Returns:
    
    the squared scale factor on the X axis
  - getScaleYSquared
```
public double getScaleYSquared()
```
    Returns:
    
    the squared scale factor on the Y axis
  - getScaleZSquared
```
public double getScaleZSquared()
```
    Returns:
    
    the squared scale factor on the Z axis
  - getScaleX
```
public double getScaleX()
```
    Returns:
    
    the scale factor on the X axis (non-negative)
  - getScaleY
```
public double getScaleY()
```
    Returns:
    
    the scale factor on the Y axis (non-negative)
  - getScaleZ
```
public double getScaleZ()
```
    Returns:
    
    the scale factor on the X axis (non-negative)
  - getScale
```
public Vector3d getScale(Vector3d scale)
```
  - toNormalMatrix
```
public Matrix4d toNormalMatrix()
```
    removes the translational part and transposes the matrix.
  - prj
```
public static void prj(double[] mat,
                       double[] 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 Vector3d.prj(Matrix4d).
    
    Parameters:
    
    mat - the matrix
    
    vec - the vector.
  - prj
```
public static void prj(double[] mat,
                       double[] 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 Matrix4.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
  - translate
```
public Matrix4d translate(Vector3d 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 Matrix4d translate(double[] 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 Matrix4d translate(double x,
                          double y,
                          double 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.
  - mul
```
public static void mul(double[] mata,
                       double[] 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(Matrix4d).
    
    Parameters:
    
    mata - the first matrix.
    
    matb - the second matrix.
  - rotate
```
public Matrix4d rotate(Vector3d axis,
                       double 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 Matrix4d rotateRad(Vector3d axis,
                          double 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 Matrix4d rotate(double axisX,
                       double axisY,
                       double axisZ,
                       double 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 Matrix4d rotateRad(double axisX,
                          double axisY,
                          double axisZ,
                          double 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 Matrix4d rotate(Quaterniond 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 Matrix4d rotate(Vector3d v1,
                       Vector3d 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 Matrix4d scale(double scaleX,
                      double scaleY,
                      double 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(double[] dst)
```
    Copies the 4x3 upper-left sub-matrix into double array. The destination array is supposed to be a column major matrix.
    
    Parameters:
    
    dst - the destination matrix
  - putIn
```
public com.badlogic.gdx.math.Matrix4 putIn(com.badlogic.gdx.math.Matrix4 aux)
```
    Sets the given matrix to this matrix
    
    Parameters:
    
    aux - The out matrix
    
    Returns:
    
    The aux matrix

Class Matrix4d

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

stmp

tmp

val

Constructor Detail

Matrix4d

Matrix4d

Matrix4d

Matrix4d

Matrix4d

Matrix4d

Method Detail

set

set

set

set

set

set

set

set

set

set

cpy

trn

trn

getValues

mul

mulLeft

tra

idt

inv

inv

det

det3x3

setToProjection

setToOrtho2D

setToOrtho2D

setToOrtho

setTranslation

setTranslation

setToTranslation

setToTranslation

setToTranslation

setToTranslationAndScaling

setToTranslationAndScaling

setToRotation

setToRotationRad

setToRotation

setToRotationRad

setToRotation

setToRotation

setFromEulerAngles

setToScaling

setToScaling

setToLookAt

setToLookAt

setToWorld

toString

lerp