Mat4x4 (Bonzai Engine bonzaiengine.com Copyright © 2007-2019 Jérôme Jouvie)

java.lang.Object
- com.bonzaiengine.math.Mat4x4

All Implemented Interfaces:

IValueCopy<Mat4x4>, java.lang.Cloneable
```
public final class Mat4x4
extends java.lang.Object
implements IValueCopy<Mat4x4>
```
A 4x4 matrix with same notation as OpenGL.

Rotation Matrix
A rotation matrix is in the format of :
| left.x up.x forward.x pos.x |
| left.y up.y forward.y pos.y |
| left.z up.z forward.z pos.z |
| 0 0 0 1 |

Look at matrix
A look at matrix is in the format of :
| -left.x -left.y -left.z a |
| up.x up.y up.z b |
| -forward.x -forward.y -forward.z c |
| 0 0 0 1 |
with
a = left.x * pos.x + left.y * pos.y + left.z * pos.z
b = -up.x * pos.x + -up.y * pos.y + -up.z * pos.z
c = forward.x * pos.x + forward.y * pos.y + forward.z * pos.z

Field Summary

Fields
Modifier and Type Field and Description

static Mat4x4 IDENTITY
Don't modify the value.

float[] m
Matrix elements, in OpenGL ordering

Fields
Modifier and Type	Field and Description
`static Mat4x4`	`IDENTITY` Don't modify the value.
`float[]`	`m` Matrix elements, in OpenGL ordering

Constructor Summary

Constructors
Constructor and Description

Mat4x4()
A matrix with all elements of 0.

Mat4x4(float... m)

Constructors
Constructor and Description
`Mat4x4()` A matrix with all elements of 0.
`Mat4x4(float... m)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Mat4x4`	`abs3x3()`
`static Mat4x4[]`	`allocate(int num)`
`Mat4x4`	`clone()`
`float`	`determinant()`
`float`	`determinant3x3()`
`float`	`distance(Mat4x4 m)`
`boolean`	`equals(java.lang.Object obj)`
`Vec3`	`getAnglesXYZ(Vec3 dst)` Convert this matrix into angles ordered: x, y, z Reference: http://jeux.developpez.com/faq/matquat/?
`Vec3`	`getAnglesZYX(Vec3 dst)` Convert this matrix into angles ordered: z, y, x Reference: http://jeux.developpez.com/faq/matquat/?
`Vec3`	`getAxisX(Vec3 dst)`
`Vec3`	`getAxisY(Vec3 dst)`
`Vec3`	`getAxisZ(Vec3 dst)`
`Vec3`	`getLookAtForward(Vec3 dst)`
`Vec3`	`getLookAtLeft(Vec3 dst)`
`Vec3`	`getLookAtPosition(Vec3 dst)`
`Quat`	`getLookAtRotation(Quat dst)`
`Vec3`	`getLookAtUp(Vec3 dst)`
`float`	`getPerspectiveFar()`
`float`	`getPerspectiveNear()`
`void`	`getRotationAndScale(Quat q, Vec3 scale)` WARNING: This is not a general way to convert a matrix into a quaternion !
`Vec3`	`getScale(Vec3 dst)`
`Vec3`	`getScale3x3(Vec3 dst)`
`Vec3`	`getTranslationLocal(Vec3 dst)`
`Vec3`	`getTranslationWorld(Vec3 dst)`
`int`	`hashCode()`
`static Mat4x4`	`identity()`
`Mat4x4`	`inverse(Mat4x4 src)` Inverse the source matric in this
`Mat4x4`	`inverse3x3(Mat4x4 src)` Inverse the 3x3 block of the source matrix in this
`Mat4x4`	`inverseTranspose(Mat4x4 src)` Inverse and transpose the source matrix in this
`boolean`	`isIdentity()`
`Mat4x4`	`lookAt(float eyeX, float eyeY, float eyeZ, float refX, float refY, float refZ, float upX, float upY, float upZ)` Create a look at matrix, and store in this matrix
`Mat4x4`	`lookAt(Quat q, Vec3 position)` Create a look at matrix, and store in this matrix
`Mat4x4`	`lookAt(Vec3 eye, Vec3 ref, Vec3 up)` Create a look at matrix, and store in this matrix
`Mat4x4`	`lookAt(Vec3 left, Vec3 up, Vec3 forward, Vec3 position)` Create a look at matrix, and store in this matrix
`Mat4x4`	`multiply(Mat4x4 mat1, Mat4x4 mat2)` Multiply two matrices and store the result in `this` matrix.
`static Mat4x4`	`multiply(Mat4x4 dst, Mat4x4 m1, Mat4x4 m2)`
`Vec3`	`multiply(Vec3 dst, Vec3 src)` Multiply (rotate and translate) a vector by this matrix.
`Vec4`	`multiply(Vec4 dst, Vec4 src)` Multiply (rotate and translate) a vector by this matrix.
`Mat4x4`	`multiply3x3(Mat4x4 mat1, Mat4x4 mat2)` Multiply the 3x3 block of two matrices and store the result into the 3x3 block of `this` matrix.
`Mat4x4`	`multiply3x4(Mat4x4 mat1, Mat4x4 mat2)` Multiply the 3x4 block of two matrices and store the result in `this` matrix.
`Vec3`	`multiplyDivW(Vec3 dst, Vec3 src)` Multiply a vector by this matrix, with perspective correction.
`Vec3`	`multiplyInverseLookAt(Vec3 dst, Vec3 src)` Equivalent: new Mat4x4().inverse(this).multiply(dst, src) Only valid if this is a lookAt matrix
`Mat4x4`	`multiplyProjectionModelview(Mat4x4 proj, Mat4x4 view)` A fast perspective * modelview multiplication (support Lengyel mperspective matrix).
`Vec4`	`multiplyTransposed(Vec4 dst, Vec4 src)` Multiply (rotate and translate) a vector by the transpose of this matrix.
`void`	`obliqueClipPlane(Mat4x4 proj, Mat4x4 view, Plane clipPlane)` References: [1] http://www.nvidia.fr/object/oblique_frustum_clipping.html [2] Modifying the Projection Matrix to Perform Oblique Near-Plane Clipping (Lengyel’s Frustum) http://www.terathon.com/code/oblique.html Lengyel, Eric.
`Mat4x4`	`rotate(Quat q)` Multiply the 3x3 matrix block o this matrix with the specified quaternion.
`Mat4x4`	`scale(Vec3 scale)` Scale the 4x3 block of this matrix.
`Mat4x4`	`scale3x3(Vec3 scale)` Scale the 3x3 block of this matrix.
`Mat4x4`	`set(Mat4x4 src)`
`Mat4x4`	`set3x3(Mat4x4 src)`
`Mat4x4`	`setAnglesXYZ(float angleXInRadians, float angleYInRadians, float angleZInRadians)` Create a matrix from angles, as defined by the order: x, y, z This method is equivalent to (code has been optimized): final Mat4x4 m_ = new Mat4x4(); setIdentity3x3(); multiply3x3(this, m_.setXRotation(angleXInRadians)); multiply3x3(this, m_.setYRotation(angleYInRadians)); multiply3x3(this, m_.setZRotation(angleZInRadians));
`Mat4x4`	`setAnglesZYX(float angleXInRadians, float angleYInRadians, float angleZInRadians)` Create a matrix from angles, as defined by the order: z, y, x This method is equivalent to (code has been optimized): final Mat4x4 m_ = new Mat4x4(); setIdentity3x3(); multiply3x3(this, m_.setZRotation(angleZInRadians)); multiply3x3(this, m_.setYRotation(angleYInRadians)); multiply3x3(this, m_.setXRotation(angleXInRadians));
`Mat4x4`	`setAxisAngle(Vec3 axis, float angleInRadians)` Set 3x3 matrix block to represent the specified rotation.
`Mat4x4`	`setFrustumProjection(float left, float right, float bottom, float top, float zNear, float zFar)` Set this matrix as a frustum matrix
`Mat4x4`	`setIdentity()` Set this matrix as the identity matrix
`Mat4x4`	`setIdentity3x3()` Set this matrix as the identity matrix
`Mat4x4`	`setOrthographicProjection(float left, float right, float bottom, float top, float near, float far)` Set this matrix as an orthographic matrix
`Mat4x4`	`setPerspectiveProjection(float fovYInDegrees, float aspect, float zNear, float zFar)` Set this matrix as a perspective matrix
`Mat4x4`	`setPickMatrix(float x, float y, float width, float height, Viewport viewport)` Create a matrix equivalent to gluPickMatrix
`Mat4x4`	`setRotation(Quat q)` Set 3x3 matrix block to represent the specified rotation.
`Mat4x4`	`setRotation(Vec3 axisX, Vec3 axisY, Vec3 axisZ)` Set 3x3 matrix block to represent the specified rotation.
`Mat4x4`	`setRotationX(float angleInRadians)` Set 3x3 matrix block to represent the specified rotation.
`Mat4x4`	`setRotationY(float angleInRadians)` Set 3x3 matrix block to represent the specified rotation.
`Mat4x4`	`setRotationZ(float angleInRadians)` Set 3x3 matrix block to represent the specified rotation.
`Mat4x4`	`setTranslationWorld(Vec3 translate)`
`java.lang.String`	`toString()`
`float`	`trace()`
`float`	`trace3x3()`
`Vec3`	`transform(Vec3 dst, Vec3 src)` Transform (rotate) a vector by this matrix.
`Vec3`	`transformInverseLookAt(Vec3 dst, Vec3 src)` Equivalent: new Mat4x4().inverse(this).transform(dst, src) Only valid if this is a lookAt matrix
`Vec3`	`transformTransposed(Vec3 dst, Vec3 src)` Transform (rotate) a vector by this matrix transposed.
`Mat4x4`	`translateLocal(Vec3 translate)`
`Mat4x4`	`translateWorld(Vec3 translate)`
`Mat4x4`	`transpose()` Transpose this matrix This is an optimized version of `#transpose(Mat4x4)`, in the case of the source and destination matrix are identical
`Mat4x4`	`transpose(Mat4x4 src)` Transpose the `src` matrix into this matrix.
`Mat4x4`	`transpose3x3()` Transpose the 3x3 block of this matrix.
`Mat4x4`	`transpose3x3(Mat4x4 src)` Transpose the 3x3 block of the specified matrix into this
`Mat4x4`	`unscale()` Unscale the 4x3 block of this matrix.
`Mat4x4`	`unscale3x3()` Unscale the 3x3 block of this matrix.

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

- Field Detail
  - IDENTITY
```
public static final Mat4x4 IDENTITY
```
    Don't modify the value. Value should remains the identity matrix
  - m
```
public final float[] m
```
    Matrix elements, in OpenGL ordering
- Constructor Detail
  - Mat4x4
```
public Mat4x4()
```
    A matrix with all elements of 0.
    
    See Also:
    
    identity()
  - Mat4x4
```
public Mat4x4(float... m)
       throws java.lang.IllegalArgumentException
```
    Parameters:
    
    m - a float[16]
    
    Throws:
    
    IllegalArgumentException, - when array is null or length is not 16
    
    java.lang.IllegalArgumentException
- Method Detail
  - identity
```
public static final Mat4x4 identity()
```
    Returns:
    
    a new identity matrix
  - allocate
```
public static final Mat4x4[] allocate(int num)
```
    Returns:
    
    a Mat4x4[] of length num containing new identity matrices
  - equals
```
public final boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public final java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - clone
```
public final Mat4x4 clone()
```
    Specified by:
    
    clone in interface IValueCopy<Mat4x4>
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    
    a clone of this matrix
  - isIdentity
```
public final boolean isIdentity()
```
    Returns:
    
    true if this matrix is the identity matrix
  - distance
```
public final float distance(Mat4x4 m)
```
    Returns:
    
    the distance considering the matrix as a 16 length vector
  - set
```
public final Mat4x4 set(Mat4x4 src)
```
    Specified by:
    
    set in interface IValueCopy<Mat4x4>
    
    Parameters:
    
    src - source matrix to copy to this matrix
    
    Returns:
    
    this matrix
  - set3x3
```
public final Mat4x4 set3x3(Mat4x4 src)
```
    Parameters:
    
    src - source matrix to copy to this matrix
    
    Returns:
    
    this matrix
  - setIdentity
```
public final Mat4x4 setIdentity()
```
    Set this matrix as the identity matrix
  - setIdentity3x3
```
public final Mat4x4 setIdentity3x3()
```
    Set this matrix as the identity matrix
  - abs3x3
```
public final Mat4x4 abs3x3()
```
  - translateLocal
```
public final Mat4x4 translateLocal(Vec3 translate)
```
    Parameters:
    
    translate - local translation vector
    
    Returns:
    
    this
  - getTranslationLocal
```
public final Vec3 getTranslationLocal(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the local translation.
    If the matrix contains scale, the local translation will be scale too.
    
    Returns:
    
    dst
  - translateWorld
```
public final Mat4x4 translateWorld(Vec3 translate)
```
    Parameters:
    
    translate - world translation vector
    
    Returns:
    
    this
  - setTranslationWorld
```
public final Mat4x4 setTranslationWorld(Vec3 translate)
```
    Parameters:
    
    translate - world translation vector
    
    Returns:
    
    this
  - getTranslationWorld
```
public final Vec3 getTranslationWorld(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the world translation
    
    Returns:
    
    dst
  - setAxisAngle
```
public final Mat4x4 setAxisAngle(Vec3 axis,
                                 float angleInRadians)
```
    Set 3x3 matrix block to represent the specified rotation.
    
    Parameters:
    
    angleInRadians - angle in radians
    
    Returns:
    
    this
  - setRotation
```
public final Mat4x4 setRotation(Vec3 axisX,
                                Vec3 axisY,
                                Vec3 axisZ)
```
    Set 3x3 matrix block to represent the specified rotation.
    If vector a not normalized, the matrix will also represent scaling.
    
    Parameters:
    
    axisX - x axis. If not normalized, the magnitude of the vector will be the scale along x.
    
    axisY - y axis. If not normalized, the magnitude of the vector will be the scale along y.
    
    axisZ - z axis. If not normalized, the magnitude of the vector will be the scale along z.
    
    Returns:
    
    this
  - setRotationX
```
public final Mat4x4 setRotationX(float angleInRadians)
```
    Set 3x3 matrix block to represent the specified rotation.
    
    Parameters:
    
    angleInRadians - x rotation angle in radians
    
    Returns:
    
    this
  - setRotationY
```
public final Mat4x4 setRotationY(float angleInRadians)
```
    Set 3x3 matrix block to represent the specified rotation.
    
    Parameters:
    
    angleInRadians - y rotation angle in radians
    
    Returns:
    
    this
  - setRotationZ
```
public final Mat4x4 setRotationZ(float angleInRadians)
```
    Set 3x3 matrix block to represent the specified rotation.
    
    Parameters:
    
    angleInRadians - z rotation angle in radians
    
    Returns:
    
    this
  - setRotation
```
public final Mat4x4 setRotation(Quat q)
```
    Set 3x3 matrix block to represent the specified rotation.
    
    Parameters:
    
    q - a quaternion defining the rotation
    
    Returns:
    
    this
    
    See Also:
    
    Quat.getMatrix3x3(Mat4x4)
  - rotate
```
public final Mat4x4 rotate(Quat q)
```
    Multiply the 3x3 matrix block o this matrix with the specified quaternion.
    
    Parameters:
    
    q - a quaternion defining a rotation matrix
    
    Returns:
    
    this
  - getRotationAndScale
```
public final void getRotationAndScale(Quat q,
                                      Vec3 scale)
```
    WARNING: This is not a general way to convert a matrix into a quaternion !
    The only general way to decompose a matrix is by using the Transform representation.
    
    This is only valid for a matrix created by a combination of a Translation, a Rotation and a Scale.
    Other matrix result to an undefined result.
    
    Parameters:
    
    q - destination to store the rotation of this matrix
    
    scale - destination to store the scale of this matrix
    
    See Also:
    
    Transform.getMatrix(Mat4x4)
  - getAxisX
```
public final Vec3 getAxisX(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the axis x.
    If the matrix contain scale along x, the axis x will be scaled too.
    
    Returns:
    
    dst
  - getAxisY
```
public final Vec3 getAxisY(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the axis y.
    If the matrix contain scale along x, the axis x will be scaled too.
    
    Returns:
    
    dst
  - getAxisZ
```
public final Vec3 getAxisZ(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the axis z.
    If the matrix contain scale along x, the axis x will be scaled too.
    
    Returns:
    
    dst
  - setAnglesXYZ
```
public final Mat4x4 setAnglesXYZ(float angleXInRadians,
                                 float angleYInRadians,
                                 float angleZInRadians)
```
    Create a matrix from angles, as defined by the order: x, y, z
    
    This method is equivalent to (code has been optimized):
```
  final Mat4x4 m_ = new Mat4x4();
  setIdentity3x3();
  multiply3x3(this, m_.setXRotation(angleXInRadians));
  multiply3x3(this, m_.setYRotation(angleYInRadians));
  multiply3x3(this, m_.setZRotation(angleZInRadians));
  
```
    Parameters:
    
    angleXInRadians - rotation around x, in radians
    
    angleYInRadians - rotation around y, in radians
    
    angleZInRadians - rotation around z, in radians
    
    Returns:
    
    this
  - setAnglesZYX
```
public final Mat4x4 setAnglesZYX(float angleXInRadians,
                                 float angleYInRadians,
                                 float angleZInRadians)
```
    Create a matrix from angles, as defined by the order: z, y, x
    
    This method is equivalent to (code has been optimized):
```
  final Mat4x4 m_ = new Mat4x4();
  setIdentity3x3();
  multiply3x3(this, m_.setZRotation(angleZInRadians));
  multiply3x3(this, m_.setYRotation(angleYInRadians));
  multiply3x3(this, m_.setXRotation(angleXInRadians));
  
```
    Parameters:
    
    angleXInRadians - rotation around x, in radians
    
    angleYInRadians - rotation around y, in radians
    
    angleZInRadians - rotation around z, in radians
    
    Returns:
    
    this
  - getAnglesXYZ
```
public final Vec3 getAnglesXYZ(Vec3 dst)
```
    Convert this matrix into angles ordered: x, y, z
    
    Reference: http://jeux.developpez.com/faq/matquat/?page=transformations#Q37
    
    Parameters:
    
    dst - destination vector to store the angles in radians (angleX, angleY, angleZ)
  - getAnglesZYX
```
public final Vec3 getAnglesZYX(Vec3 dst)
```
    Convert this matrix into angles ordered: z, y, x
    
    Reference: http://jeux.developpez.com/faq/matquat/?page=transformations#Q37
    
    Parameters:
    
    dst - destination vector to store the angles in radians (angleX, angleY, angleZ)
  - scale
```
public final Mat4x4 scale(Vec3 scale)
```
    Scale the 4x3 block of this matrix.
    If the last row is (0, 0, 0, 1), this is equivalent to #scale3x3(Vector3f)
    
    Parameters:
    
    scale - a scale vector defining teh scale along x, y and z axis.
    
    Returns:
    
    this
    
    See Also:
    
    scale3x3(Vec3)
  - scale3x3
```
public final Mat4x4 scale3x3(Vec3 scale)
```
    Scale the 3x3 block of this matrix.
    
    Parameters:
    
    scale - a scale vector defining the scale along x, y and z axis.
    
    Returns:
    
    this
  - getScale
```
public final Vec3 getScale(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the (positive) scale of this matrix
    
    Returns:
    
    dst
    
    See Also:
    
    getRotationAndScale(Quat, Vec3), Transform
  - getScale3x3
```
public final Vec3 getScale3x3(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the (positive) scale of the 3x3 block of this matrix
    
    Returns:
    
    dst
    
    See Also:
    
    getRotationAndScale(Quat, Vec3), Transform
  - unscale
```
public final Mat4x4 unscale()
```
    Unscale the 4x3 block of this matrix.
    If the last row is (0, 0, 0, 1), this is equivalent to #unscale3x3()
    
    Returns:
    
    this
    
    See Also:
    
    unscale3x3()
  - unscale3x3
```
public final Mat4x4 unscale3x3()
```
    Unscale the 3x3 block of this matrix.
    If the last row is (0, 0, 0, 1), this is equivalent to #unscale3x3()
    
    Returns:
    
    this
    
    See Also:
    
    unscale3x3()
  - multiplyProjectionModelview
```
public final Mat4x4 multiplyProjectionModelview(Mat4x4 proj,
                                                Mat4x4 view)
```
    A fast perspective * modelview multiplication (support Lengyel mperspective matrix).
    Equivalent to #multiply(Mat4x4, Mat4x4), but faster.
    
    Parameters:
    
    proj - a perspective projection matrix.
    
    view - a modelview matrix.
    
    Returns:
    
    this
    
    See Also:
    
    multiply(Mat4x4, Mat4x4)
  - multiply
```
public final Mat4x4 multiply(Mat4x4 mat1,
                             Mat4x4 mat2)
```
    Multiply two matrices and store the result in this matrix.
    
    Parameters:
    
    mat1 - first matrix, can be this or mat2.
    
    mat2 - second matrix, can be this or mat1.
    
    Returns:
    
    this
  - multiply3x4
```
public final Mat4x4 multiply3x4(Mat4x4 mat1,
                                Mat4x4 mat2)
```
    Multiply the 3x4 block of two matrices and store the result in this matrix.
    This is a specialized (and optimized) version of #multiply(Mat4x4, Mat4x4) , given that the last row of the matrices is (0, 0, 0, 1).
    
    Parameters:
    
    mat1 - first matrix, can be this or mat2.
    
    mat2 - second matrix, can be this or mat1.
    
    Returns:
    
    this
  - multiply3x3
```
public final Mat4x4 multiply3x3(Mat4x4 mat1,
                                Mat4x4 mat2)
```
    Multiply the 3x3 block of two matrices and store the result into the 3x3 block of this matrix.
    
    Parameters:
    
    mat1 - first matrix, can be this or mat2.
    
    mat2 - second matrix, can be this or mat1.
    
    Returns:
    
    this
  - multiply
```
public static final Mat4x4 multiply(Mat4x4 dst,
                                    Mat4x4 m1,
                                    Mat4x4 m2)
```
  - lookAt
```
public final Mat4x4 lookAt(float eyeX,
                           float eyeY,
                           float eyeZ,
                           float refX,
                           float refY,
                           float refZ,
                           float upX,
                           float upY,
                           float upZ)
```
    Create a look at matrix, and store in this matrix
    
    Parameters:
    
    eyeX - eye position, x component
    
    eyeY - eye position, y component
    
    eyeZ - eye position, z component
    
    refX - look at point, x component
    
    refY - look at point, y component
    
    refZ - look at point, z component
    
    upX - up direction, x component
    
    upY - up direction, y component
    
    upZ - up direction, z component
    
    Returns:
    
    this
  - lookAt
```
public final Mat4x4 lookAt(Vec3 eye,
                           Vec3 ref,
                           Vec3 up)
```
    Create a look at matrix, and store in this matrix
    
    Parameters:
    
    eye - eye position
    
    ref - look at point
    
    up - up direction
    
    Returns:
    
    this
  - lookAt
```
public final Mat4x4 lookAt(Vec3 left,
                           Vec3 up,
                           Vec3 forward,
                           Vec3 position)
```
    Create a look at matrix, and store in this matrix
    
    Parameters:
    
    left - left normalized vector
    
    up - up normalized vector
    
    forward - forward normalized vector
    
    position - eye view point/position
    
    Returns:
    
    this
  - lookAt
```
public final Mat4x4 lookAt(Quat q,
                           Vec3 position)
```
    Create a look at matrix, and store in this matrix
    
    Parameters:
    
    q - a quaternion defining the left/up/forward vectors
    
    position - eye position
    
    Returns:
    
    this
  - getLookAtLeft
```
public final Vec3 getLookAtLeft(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the left vector of this look at matrix
    
    Returns:
    
    dst
  - getLookAtUp
```
public final Vec3 getLookAtUp(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the up vector of this look at matrix
    
    Returns:
    
    dst
  - getLookAtForward
```
public final Vec3 getLookAtForward(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the forward vector of this look at matrix
    
    Returns:
    
    dst
  - getLookAtPosition
```
public final Vec3 getLookAtPosition(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the eye position vector of this look at matrix
    
    Returns:
    
    dst
  - getLookAtRotation
```
public final Quat getLookAtRotation(Quat dst)
```
    Parameters:
    
    dst - destination quaternion to store the orientation (left/forward/up vectors) of this look at matrix.
    
    Returns:
    
    dst
  - multiply
```
public final Vec3 multiply(Vec3 dst,
                           Vec3 src)
```
    Multiply (rotate and translate) a vector by this matrix.
    The w component of the vector is implicitly 1.
    
    Parameters:
    
    src - source vector
    
    dst - destination vector to store the result
    
    Returns:
    
    dst
  - multiply
```
public final Vec4 multiply(Vec4 dst,
                           Vec4 src)
```
    Multiply (rotate and translate) a vector by this matrix.
    
    Parameters:
    
    src - source vector
    
    dst - destination vector to store the result
    
    Returns:
    
    dst
  - multiplyTransposed
```
public final Vec4 multiplyTransposed(Vec4 dst,
                                     Vec4 src)
```
    Multiply (rotate and translate) a vector by the transpose of this matrix.
    
    Parameters:
    
    src - source vector
    
    dst - destination vector to store the result
    
    Returns:
    
    dst
  - multiplyInverseLookAt
```
public Vec3 multiplyInverseLookAt(Vec3 dst,
                                  Vec3 src)
```
    Equivalent: new Mat4x4().inverse(this).multiply(dst, src)
    Only valid if this is a lookAt matrix
  - multiplyDivW
```
public final Vec3 multiplyDivW(Vec3 dst,
                               Vec3 src)
```
    Multiply a vector by this matrix, with perspective correction.
    The input is assumed with w = 1, output vector is divided by w (so equals to 1 too).
    
    Parameters:
    
    src - source vector
    
    dst - destination vector to store the result
    
    Returns:
    
    dst
  - transform
```
public final Vec3 transform(Vec3 dst,
                            Vec3 src)
```
    Transform (rotate) a vector by this matrix.
    
    Parameters:
    
    src - source vector
    
    dst - destination vector to store the result
    
    Returns:
    
    dst
  - transformTransposed
```
public final Vec3 transformTransposed(Vec3 dst,
                                      Vec3 src)
```
    Transform (rotate) a vector by this matrix transposed.
    
    Parameters:
    
    src - source vector
    
    dst - destination vector to store the result
    
    Returns:
    
    dst
  - transformInverseLookAt
```
public Vec3 transformInverseLookAt(Vec3 dst,
                                   Vec3 src)
```
    Equivalent: new Mat4x4().inverse(this).transform(dst, src)
    Only valid if this is a lookAt matrix
  - transpose3x3
```
public final Mat4x4 transpose3x3(Mat4x4 src)
```
    Transpose the 3x3 block of the specified matrix into this
    
    Parameters:
    
    src - source matrix to transpose
    
    Returns:
    
    this
  - transpose3x3
```
public final Mat4x4 transpose3x3()
```
    Transpose the 3x3 block of this matrix.
    This is an optimized version of #transpose3x3(Mat4x4), in the case of the source and destination matrix are identical
    
    Returns:
    
    this
    
    See Also:
    
    transpose3x3(Mat4x4)
  - transpose
```
public final Mat4x4 transpose(Mat4x4 src)
```
    Transpose the src matrix into this matrix.
    
    Parameters:
    
    src - matrix to transpose in this
    
    Returns:
    
    this containing src transposed
  - transpose
```
public final Mat4x4 transpose()
```
    Transpose this matrix
    This is an optimized version of #transpose(Mat4x4), in the case of the source and destination matrix are identical
    
    Returns:
    
    this
    
    See Also:
    
    transpose(Mat4x4)
  - trace
```
public final float trace()
```
    Returns:
    
    the trace of this matrix
  - trace3x3
```
public final float trace3x3()
```
    Returns:
    
    the trace of the 3x3 block of this matrix
  - determinant
```
public final float determinant()
```
    Returns:
    
    the matrix determinant of the 4x4 block
  - determinant3x3
```
public final float determinant3x3()
```
    Returns:
    
    the matrix determinant of the 3x3 block
  - inverse
```
public final Mat4x4 inverse(Mat4x4 src)
```
    Inverse the source matric in this
    
    Parameters:
    
    src - source matrix to inverse
    
    Returns:
    
    this
    
    Throws:
    
    java.lang.IllegalArgumentException - if determinant of src matrix is 0
  - inverse3x3
```
public final Mat4x4 inverse3x3(Mat4x4 src)
```
    Inverse the 3x3 block of the source matrix in this
    
    Parameters:
    
    src - source matrix to inverse
    
    Returns:
    
    this
    
    Throws:
    
    java.lang.IllegalArgumentException - if determinant of src matrix is 0
  - inverseTranspose
```
public final Mat4x4 inverseTranspose(Mat4x4 src)
```
    Inverse and transpose the source matrix in this
    
    Parameters:
    
    src - source matrix to inverse and transpose
    
    Returns:
    
    this
    
    Throws:
    
    java.lang.IllegalArgumentException - if determinant of src matrix is 0
  - setFrustumProjection
```
public final Mat4x4 setFrustumProjection(float left,
                                         float right,
                                         float bottom,
                                         float top,
                                         float zNear,
                                         float zFar)
```
    Set this matrix as a frustum matrix
    
    Parameters:
    
    left -
    
    right -
    
    bottom -
    
    top -
    
    zNear -
    
    zFar -
    
    Returns:
    
    this
  - setPerspectiveProjection
```
public final Mat4x4 setPerspectiveProjection(float fovYInDegrees,
                                             float aspect,
                                             float zNear,
                                             float zFar)
```
    Set this matrix as a perspective matrix
    
    Parameters:
    
    fovYInDegrees - fov Y angle in degree
    
    aspect -
    
    zNear -
    
    zFar -
    
    Returns:
    
    this
  - obliqueClipPlane
```
public void obliqueClipPlane(Mat4x4 proj,
                             Mat4x4 view,
                             Plane clipPlane)
```
    References:
    [1] http://www.nvidia.fr/object/oblique_frustum_clipping.html
    [2] Modifying the Projection Matrix to Perform Oblique Near-Plane Clipping (Lengyel’s Frustum)
    http://www.terathon.com/code/oblique.html
    Lengyel, Eric. "Oblique View Frustum Depth Projection and Clipping". Journal of Game Development,
    Vol. 1, No. 2 (2005), Charles River Media, pp. 5–16.
    
    Parameters:
    
    proj -
    
    view -
  - getPerspectiveNear
```
public final float getPerspectiveNear()
```
    Returns:
    
    near plane, this Mat4x4 must be a perspective matrix as defined by OpenGL.
    
    See Also:
    
    setPerspectiveProjection(float, float, float, float)
  - getPerspectiveFar
```
public final float getPerspectiveFar()
```
    Returns:
    
    far plane, this Mat4x4 must be a perspective matrix as defined by OpenGL.
    
    See Also:
    
    setPerspectiveProjection(float, float, float, float)
  - setOrthographicProjection
```
public final Mat4x4 setOrthographicProjection(float left,
                                              float right,
                                              float bottom,
                                              float top,
                                              float near,
                                              float far)
```
    Set this matrix as an orthographic matrix
    
    Parameters:
    
    left -
    
    right -
    
    bottom -
    
    top -
    
    near -
    
    far -
    
    Returns:
    
    this
  - setPickMatrix
```
public final Mat4x4 setPickMatrix(float x,
                                  float y,
                                  float width,
                                  float height,
                                  Viewport viewport)
```
    Create a matrix equivalent to gluPickMatrix
    
    Parameters:
    
    x -
    
    y -
    
    width -
    
    height -
    
    viewport - viewport area
    
    Returns:
    
    this

Class Mat4x4

Rotation Matrix

Look at matrix

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

IDENTITY

m

Constructor Detail

Mat4x4

Mat4x4

Method Detail

identity

allocate

equals

hashCode

toString

clone

isIdentity

distance

set

set3x3

setIdentity

setIdentity3x3

abs3x3

translateLocal

getTranslationLocal

translateWorld

setTranslationWorld

getTranslationWorld

setAxisAngle

setRotation

setRotationX

setRotationY

setRotationZ

setRotation

rotate

getRotationAndScale

getAxisX

getAxisY

getAxisZ

setAnglesXYZ

setAnglesZYX

getAnglesXYZ

getAnglesZYX

scale

scale3x3

getScale

getScale3x3

unscale

unscale3x3

multiplyProjectionModelview

multiply

multiply3x4

multiply3x3

multiply

lookAt

lookAt

lookAt

lookAt

getLookAtLeft

getLookAtUp

getLookAtForward

getLookAtPosition

getLookAtRotation

multiply

multiply

multiplyTransposed

multiplyInverseLookAt

multiplyDivW

transform

transformTransposed

transformInverseLookAt

transpose3x3

transpose3x3

transpose

transpose

trace