Matrix4 (libGDX Core 1.0.0 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.badlogic.gdx.math
Class Matrix4

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

All Implemented Interfaces:: Serializable

public class Matrix4
extends Object
implements Serializable
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
`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[]`	`tmp`
`float[]`	`val`

Constructor Summary
`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
`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(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`	`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 fov, 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`	`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

tmp

public final float[] tmp

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 fov,
                               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.

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 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.

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

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)

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

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.badlogic.gdx.math Class Matrix4

M00

M01

M02

M03

M10

M11

M12

M13

M20

M21

M22

M23

M30

M31

M32

M33

tmp

val

Matrix4

Matrix4

Matrix4

Matrix4

Matrix4

set

set

set

set

set

set

set

set

set

cpy

trn

trn

getValues

mul

mulLeft

tra

idt

inv

det

det3x3

setToProjection

setToOrtho2D

setToOrtho2D

setToOrtho

setTranslation

setTranslation

setToTranslation

setToTranslation

setToTranslationAndScaling

setToTranslationAndScaling

setToRotation

setToRotationRad

setToRotation

setToRotationRad

setToRotation

setToRotation

setFromEulerAngles

setToScaling

setToScaling

setToLookAt

setToLookAt

setToWorld

toString

lerp

set

scl

scl

scl

getTranslation

getRotation

getRotation

getScaleXSquared

getScaleYSquared

getScaleZSquared

getScaleX

getScaleY

com.badlogic.gdx.math
Class Matrix4