Matrix4x3d

Contains the definition of an affine 4x3 matrix (4 columns, 3 rows) of doubles, and associated functions to transform it. The matrix is column-major to match OpenGL's interpretation, and it looks like this: <p> m00 m10 m20 m30<br> m01 m11 m21 m31<br> m02 m12 m22 m32<br>

@author Richard Greenlees @author Kai Burjack

struct Matrix4x3d {}

Constructors

this
this(Matrix4x3d mat)

Create a new {@link Matrix4x3d} and make it a copy of the given matrix.

this
this(Matrix3d mat)

Create a new {@link Matrix4x3d} by setting its left 3x3 submatrix to the values of the given {@link Matrix3d} and the rest to identity.

this
this(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32)

Create a new 4x4 matrix using the supplied double values.

Members

Functions

_m00
Matrix4x3d _m00(double m00)

Set the value of the matrix element at column 0 and row 0 without updating the properties of the matrix.

_m01
Matrix4x3d _m01(double m01)

Set the value of the matrix element at column 0 and row 1 without updating the properties of the matrix.

_m02
Matrix4x3d _m02(double m02)

Set the value of the matrix element at column 0 and row 2 without updating the properties of the matrix.

_m10
Matrix4x3d _m10(double m10)

Set the value of the matrix element at column 1 and row 0 without updating the properties of the matrix.

_m11
Matrix4x3d _m11(double m11)

Set the value of the matrix element at column 1 and row 1 without updating the properties of the matrix.

_m12
Matrix4x3d _m12(double m12)

Set the value of the matrix element at column 1 and row 2 without updating the properties of the matrix.

_m20
Matrix4x3d _m20(double m20)

Set the value of the matrix element at column 2 and row 0 without updating the properties of the matrix.

_m21
Matrix4x3d _m21(double m21)

Set the value of the matrix element at column 2 and row 1 without updating the properties of the matrix.

_m22
Matrix4x3d _m22(double m22)

Set the value of the matrix element at column 2 and row 2 without updating the properties of the matrix.

_m30
Matrix4x3d _m30(double m30)

Set the value of the matrix element at column 3 and row 0 without updating the properties of the matrix.

_m31
Matrix4x3d _m31(double m31)

Set the value of the matrix element at column 3 and row 1 without updating the properties of the matrix.

_m32
Matrix4x3d _m32(double m32)

Set the value of the matrix element at column 3 and row 2 without updating the properties of the matrix.

_properties
Matrix4x3d _properties(int properties)
Undocumented in source. Be warned that the author may not have intended to support it.
add
Matrix4x3d add(Matrix4x3d other, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
add
Matrix4x3d add(Matrix4x3d other)

Component-wise add <code>this</code> and <code>other</code>.

arcball
Matrix4x3d arcball(double radius, Vector3d center, double angleX, double angleY)

Apply an arcball view transformation to this matrix with the given <code>radius</code> and <code>center</code> position of the arcball and the specified X and Y rotation angles. <p> This method is equivalent to calling: <code>translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z)</code>

arcball
Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY)

Apply an arcball view transformation to this matrix with the given <code>radius</code> and center <code>(centerX, centerY, centerZ)</code> position of the arcball and the specified X and Y rotation angles. <p> This method is equivalent to calling: <code>translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-centerX, -centerY, -centerZ)</code>

arcball
Matrix4x3d arcball(double radius, Vector3d center, double angleX, double angleY, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
arcball
Matrix4x3d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
assume
Matrix4x3d assume(int properties)

Assume the given properties about this matrix. <p> Use one or multiple of 0, {@link Matrix4x3d#PROPERTY_IDENTITY}, {@link Matrix4x3d#PROPERTY_TRANSLATION}, {@link Matrix4x3d#PROPERTY_ORTHONORMAL}.

billboardCylindrical
Matrix4x3d billboardCylindrical(Vector3d objPos, Vector3d targetPos, Vector3d up)

Set this matrix to a cylindrical billboard transformation that rotates the local +Z axis of a given object with position <code>objPos</code> towards a target position at <code>targetPos</code> while constraining a cylindrical rotation around the given <code>up</code> vector. <p> This method can be used to create the complete model transformation for a given object, including the translation of the object to its position <code>objPos</code>.

billboardSpherical
Matrix4x3d billboardSpherical(Vector3d objPos, Vector3d targetPos)

Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position <code>objPos</code> towards a target position at <code>targetPos</code> using a shortest arc rotation by not preserving any <i>up</i> vector of the object. <p> This method can be used to create the complete model transformation for a given object, including the translation of the object to its position <code>objPos</code>. <p> In order to specify an <i>up</i> vector which needs to be maintained when rotating the +Z axis of the object, use {@link #billboardSpherical(Vector3d, Vector3d, Vector3d)}.

billboardSpherical
Matrix4x3d billboardSpherical(Vector3d objPos, Vector3d targetPos, Vector3d up)

Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position <code>objPos</code> towards a target position at <code>targetPos</code>. <p> This method can be used to create the complete model transformation for a given object, including the translation of the object to its position <code>objPos</code>. <p> If preserving an <i>up</i> vector is not necessary when rotating the +Z axis, then a shortest arc rotation can be obtained using {@link #billboardSpherical(Vector3d, Vector3d)}.

cofactor3x3
Matrix4x3d cofactor3x3(Matrix4x3d dest)

Compute the cofactor matrix of the left 3x3 submatrix of <code>this</code> and store it into <code>dest</code>. All other values of <code>dest</code> will be set to {@link #identity() identity}. <p> The cofactor matrix can be used instead of {@link #normal(Matrix4x3d)} to transform normals when the orientation of the normals with respect to the surface should be preserved.

cofactor3x3
Matrix3d cofactor3x3(Matrix3d dest)

Compute the cofactor matrix of the left 3x3 submatrix of <code>this</code> and store it into <code>dest</code>. <p> The cofactor matrix can be used instead of {@link #normal(Matrix3d)} to transform normals when the orientation of the normals with respect to the surface should be preserved.

cofactor3x3
Matrix4x3d cofactor3x3()

Compute the cofactor matrix of the left 3x3 submatrix of <code>this</code>. <p> The cofactor matrix can be used instead of {@link #normal()} to transform normals when the orientation of the normals with respect to the surface should be preserved.

determinant
double determinant()
Undocumented in source. Be warned that the author may not have intended to support it.
determineProperties
Matrix4x3d determineProperties()

Compute and set the matrix properties returned by {@link #properties()} based on the current matrix element values.

equals
bool equals(Matrix4x3d m, double delta)
Undocumented in source. Be warned that the author may not have intended to support it.
fma
Matrix4x3d fma(Matrix4x3d other, double otherFactor, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
fma
Matrix4x3d fma(Matrix4x3d other, double otherFactor)

Component-wise add <code>this</code> and <code>other</code> by first multiplying each component of <code>other</code> by <code>otherFactor</code> and adding that result to <code>this</code>. <p> The matrix <code>other</code> will not be changed.

frustumPlane
Vector4d frustumPlane(int which, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
get
double[] get(double[] arr)
Undocumented in source. Be warned that the author may not have intended to support it.
get
double[] get(double[] arr, int offset)
Undocumented in source. Be warned that the author may not have intended to support it.
get
Matrix4x3d get(Matrix4x3d dest)

Get the current values of <code>this</code> matrix and store them into <code>dest</code>. <p> This is the reverse method of {@link #set(Matrix4x3d)} and allows to obtain intermediate calculation results when chaining multiple transformations.

get
Matrix4d get(Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
get4x4
double[] get4x4(double[] arr)
Undocumented in source. Be warned that the author may not have intended to support it.
get4x4
double[] get4x4(double[] arr, int offset)
Undocumented in source. Be warned that the author may not have intended to support it.
getColumn
Vector3d getColumn(int column, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getEulerAnglesXYZ
Vector3d getEulerAnglesXYZ(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getEulerAnglesZYX
Vector3d getEulerAnglesZYX(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getNormalizedRotation
Quaterniond getNormalizedRotation(Quaterniond dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getRow
Vector4d getRow(int row, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getScale
Vector3d getScale(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getTranslation
Vector3d getTranslation(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getTransposed
double[] getTransposed(double[] arr)
Undocumented in source. Be warned that the author may not have intended to support it.
getTransposed
double[] getTransposed(double[] arr, int offset)
Undocumented in source. Be warned that the author may not have intended to support it.
getUnnormalizedRotation
Quaterniond getUnnormalizedRotation(Quaterniond dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getproperties
int getproperties()
Undocumented in source. Be warned that the author may not have intended to support it.
hashCode
int hashCode()
Undocumented in source. Be warned that the author may not have intended to support it.
identity
Matrix4x3d identity()

Reset this matrix to the identity. <p> Please note that if a call to {@link #identity()} is immediately followed by a call to: {@link #translate(double, double, double) translate}, {@link #rotate(double, double, double, double) rotate}, {@link #scale(double, double, double) scale}, {@link #ortho(double, double, double, double, double, double) ortho}, {@link #ortho2D(double, double, double, double) ortho2D}, {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt}, {@link #lookAlong(double, double, double, double, double, double) lookAlong}, or any of their overloads, then the call to {@link #identity()} can be omitted and the subsequent call replaced with: {@link #translation(double, double, double) translation}, {@link #rotation(double, double, double, double) rotation}, {@link #scaling(double, double, double) scaling}, {@link #setOrtho(double, double, double, double, double, double) setOrtho}, {@link #setOrtho2D(double, double, double, double) setOrtho2D}, {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt}, {@link #setLookAlong(double, double, double, double, double, double) setLookAlong}, or any of their overloads.

invert
Matrix4x3d invert(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
invert
Matrix4x3d invert()

Invert this matrix.

invertOrtho
Matrix4x3d invertOrtho()

Invert <code>this</code> orthographic projection matrix. <p> This method can be used to quickly obtain the inverse of an orthographic projection matrix.

invertOrtho
Matrix4x3d invertOrtho(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
isFinite
bool isFinite()
Undocumented in source. Be warned that the author may not have intended to support it.
lerp
Matrix4x3d lerp(Matrix4x3d other, double t)

Linearly interpolate <code>this</code> and <code>other</code> using the given interpolation factor <code>t</code> and store the result in <code>this</code>. <p> If <code>t</code> is <code>0.0</code> then the result is <code>this</code>. If the interpolation factor is <code>1.0</code> then the result is <code>other</code>.

lerp
Matrix4x3d lerp(Matrix4x3d other, double t, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
lookAlong
Matrix4x3d lookAlong(Vector3d dir, Vector3d up)

Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(Vector3d, Vector3d, Vector3d) lookAt} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(Vector3d, Vector3d) setLookAlong()}.

lookAlong
Matrix4x3d lookAlong(Vector3d dir, Vector3d up, Matrix4x3d dest)

Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(Vector3d, Vector3d, Vector3d) lookAt} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(Vector3d, Vector3d) setLookAlong()}.

lookAlong
Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest)

Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(double, double, double, double, double, double) setLookAlong()}

lookAlong
Matrix4x3d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)

Apply a rotation transformation to this matrix to make <code>-z</code> point along <code>dir</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookalong rotation matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookalong rotation transformation will be applied first! <p> This is equivalent to calling {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to set the matrix to a lookalong transformation without post-multiplying it, use {@link #setLookAlong(double, double, double, double, double, double) setLookAlong()}

lookAt
Matrix4x3d lookAt(Vector3d eye, Vector3d center, Vector3d up, Matrix4x3d dest)

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(Vector3d, Vector3d, Vector3d)}.

lookAt
Matrix4x3d lookAt(Vector3d eye, Vector3d center, Vector3d up)

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(Vector3d, Vector3d, Vector3d)}.

lookAt
Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest)

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()}.

lookAt
Matrix4x3d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)

Apply a "lookat" transformation to this matrix for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()}.

lookAtLH
Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4x3d dest)

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()}.

lookAtLH
Matrix4x3d lookAtLH(Vector3d eye, Vector3d center, Vector3d up)

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(Vector3d, Vector3d, Vector3d)}.

lookAtLH
Matrix4x3d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()}.

lookAtLH
Matrix4x3d lookAtLH(Vector3d eye, Vector3d center, Vector3d up, Matrix4x3d dest)

Apply a "lookat" transformation to this matrix for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a lookat transformation without post-multiplying it, use {@link #setLookAtLH(Vector3d, Vector3d, Vector3d)}.

mapXZY
Matrix4x3d mapXZY()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 1 0 0 1 0 0 </pre>

mapXZY
Matrix4x3d mapXZY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapXZnY
Matrix4x3d mapXZnY()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 -1 0 0 1 0 0 </pre>

mapXZnY
Matrix4x3d mapXZnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapXnYnZ
Matrix4x3d mapXnYnZ()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 -1 0 0 0 0 -1 0 </pre>

mapXnYnZ
Matrix4x3d mapXnYnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZY
Matrix4x3d mapXnZY()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 1 0 0 -1 0 0 </pre>

mapXnZY
Matrix4x3d mapXnZY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZnY
Matrix4x3d mapXnZnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapXnZnY
Matrix4x3d mapXnZnY()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 0 -1 0 0 -1 0 0 </pre>

mapYXZ
Matrix4x3d mapYXZ()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 1 0 0 0 0 0 1 0 </pre>

mapYXZ
Matrix4x3d mapYXZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYXnZ
Matrix4x3d mapYXnZ()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 1 0 0 0 0 0 -1 0 </pre>

mapYXnZ
Matrix4x3d mapYXnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYZX
Matrix4x3d mapYZX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 1 0 0 0 0 1 0 0 </pre>

mapYZX
Matrix4x3d mapYZX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYZnX
Matrix4x3d mapYZnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYZnX
Matrix4x3d mapYZnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 1 0 0 0 0 1 0 0 </pre>

mapYnXZ
Matrix4x3d mapYnXZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXZ
Matrix4x3d mapYnXZ()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 1 0 0 0 0 0 1 0 </pre>

mapYnXnZ
Matrix4x3d mapYnXnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYnXnZ
Matrix4x3d mapYnXnZ()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 1 0 0 0 0 0 -1 0 </pre>

mapYnZX
Matrix4x3d mapYnZX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYnZX
Matrix4x3d mapYnZX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 1 0 0 0 0 -1 0 0 </pre>

mapYnZnX
Matrix4x3d mapYnZnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapYnZnX
Matrix4x3d mapYnZnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 1 0 0 0 0 -1 0 0 </pre>

mapZXY
Matrix4x3d mapZXY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZXY
Matrix4x3d mapZXY()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 1 0 1 0 0 0 </pre>

mapZXnY
Matrix4x3d mapZXnY()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 -1 0 1 0 0 0 </pre>

mapZXnY
Matrix4x3d mapZXnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZYX
Matrix4x3d mapZYX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 1 0 0 1 0 0 0 </pre>

mapZYX
Matrix4x3d mapZYX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZYnX
Matrix4x3d mapZYnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 1 0 0 1 0 0 0 </pre>

mapZYnX
Matrix4x3d mapZYnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZnXY
Matrix4x3d mapZnXY()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 1 0 1 0 0 0 </pre>

mapZnXY
Matrix4x3d mapZnXY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZnXnY
Matrix4x3d mapZnXnY()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 -1 0 1 0 0 0 </pre>

mapZnXnY
Matrix4x3d mapZnXnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYX
Matrix4x3d mapZnYX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 -1 0 0 1 0 0 0 </pre>

mapZnYX
Matrix4x3d mapZnYX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapZnYnX
Matrix4x3d mapZnYnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 -1 0 0 1 0 0 0 </pre>

mapZnYnX
Matrix4x3d mapZnYnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXYnZ
Matrix4x3d mapnXYnZ()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 1 0 0 0 0 -1 0 </pre>

mapnXYnZ
Matrix4x3d mapnXYnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXZY
Matrix4x3d mapnXZY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXZY
Matrix4x3d mapnXZY()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 1 0 0 1 0 0 </pre>

mapnXZnY
Matrix4x3d mapnXZnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXZnY
Matrix4x3d mapnXZnY()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 -1 0 0 1 0 0 </pre>

mapnXnYZ
Matrix4x3d mapnXnYZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnYZ
Matrix4x3d mapnXnYZ()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 -1 0 0 0 0 1 0 </pre>

mapnXnYnZ
Matrix4x3d mapnXnYnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnYnZ
Matrix4x3d mapnXnYnZ()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 -1 0 0 0 0 -1 0 </pre>

mapnXnZY
Matrix4x3d mapnXnZY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZY
Matrix4x3d mapnXnZY()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 1 0 0 -1 0 0 </pre>

mapnXnZnY
Matrix4x3d mapnXnZnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnXnZnY
Matrix4x3d mapnXnZnY()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 0 -1 0 0 -1 0 0 </pre>

mapnYXZ
Matrix4x3d mapnYXZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYXZ
Matrix4x3d mapnYXZ()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 -1 0 0 0 0 0 1 0 </pre>

mapnYXnZ
Matrix4x3d mapnYXnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYXnZ
Matrix4x3d mapnYXnZ()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 -1 0 0 0 0 0 -1 0 </pre>

mapnYZX
Matrix4x3d mapnYZX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZX
Matrix4x3d mapnYZX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 -1 0 0 0 0 1 0 0 </pre>

mapnYZnX
Matrix4x3d mapnYZnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYZnX
Matrix4x3d mapnYZnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 -1 0 0 0 0 1 0 0 </pre>

mapnYnXZ
Matrix4x3d mapnYnXZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnXZ
Matrix4x3d mapnYnXZ()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 -1 0 0 0 0 0 1 0 </pre>

mapnYnXnZ
Matrix4x3d mapnYnXnZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnXnZ
Matrix4x3d mapnYnXnZ()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 -1 0 0 0 0 0 -1 0 </pre>

mapnYnZX
Matrix4x3d mapnYnZX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnZX
Matrix4x3d mapnYnZX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 -1 0 0 0 0 -1 0 0 </pre>

mapnYnZnX
Matrix4x3d mapnYnZnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnYnZnX
Matrix4x3d mapnYnZnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 -1 0 0 0 0 -1 0 0 </pre>

mapnZXY
Matrix4x3d mapnZXY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZXY
Matrix4x3d mapnZXY()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 1 0 -1 0 0 0 </pre>

mapnZXnY
Matrix4x3d mapnZXnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZXnY
Matrix4x3d mapnZXnY()

Multiply <code>this</code> by the matrix <pre> 0 1 0 0 0 0 -1 0 -1 0 0 0 </pre>

mapnZYX
Matrix4x3d mapnZYX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZYX
Matrix4x3d mapnZYX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 1 0 0 -1 0 0 0 </pre>

mapnZYnX
Matrix4x3d mapnZYnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZYnX
Matrix4x3d mapnZYnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 1 0 0 -1 0 0 0 </pre>

mapnZnXY
Matrix4x3d mapnZnXY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnXY
Matrix4x3d mapnZnXY()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 1 0 -1 0 0 0 </pre>

mapnZnXnY
Matrix4x3d mapnZnXnY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnXnY
Matrix4x3d mapnZnXnY()

Multiply <code>this</code> by the matrix <pre> 0 -1 0 0 0 0 -1 0 -1 0 0 0 </pre>

mapnZnYX
Matrix4x3d mapnZnYX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnYX
Matrix4x3d mapnZnYX()

Multiply <code>this</code> by the matrix <pre> 0 0 1 0 0 -1 0 0 -1 0 0 0 </pre>

mapnZnYnX
Matrix4x3d mapnZnYnX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mapnZnYnX
Matrix4x3d mapnZnYnX()

Multiply <code>this</code> by the matrix <pre> 0 0 -1 0 0 -1 0 0 -1 0 0 0 </pre>

mul
Matrix4x3d mul(Matrix4x3d right)

Multiply this matrix by the supplied <code>right</code> matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the transformation of the right matrix will be applied first!

mul
Matrix4x3d mul(Matrix4x3d right, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul3x3
Matrix4x3d mul3x3(double rm00, double rm01, double rm02, double rm10, double rm11, double rm12, double rm20, double rm21, double rm22)

Multiply <code>this</code> by the 4x3 matrix with the column vectors <code>(rm00, rm01, rm02)</code>, <code>(rm10, rm11, rm12)</code>, <code>(rm20, rm21, rm22)</code> and <code>(0, 0, 0)</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the specified matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the transformation of the <code>R</code> matrix will be applied first!

mul3x3
Matrix4x3d mul3x3(double rm00, double rm01, double rm02, double rm10, double rm11, double rm12, double rm20, double rm21, double rm22, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulComponentWise
Matrix4x3d mulComponentWise(Matrix4x3d other, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulComponentWise
Matrix4x3d mulComponentWise(Matrix4x3d other)

Component-wise multiply <code>this</code> by <code>other</code>.

mulOrtho
Matrix4x3d mulOrtho(Matrix4x3d view)

Multiply <code>this</code> orthographic projection matrix by the supplied <code>view</code> matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix, then the new matrix will be <code>M * V</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * V * v</code>, the transformation of the <code>view</code> matrix will be applied first!

mulOrtho
Matrix4x3d mulOrtho(Matrix4x3d view, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulTranslation
Matrix4x3d mulTranslation(Matrix4x3d right, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
negateX
Matrix4x3d negateX()

Multiply <code>this</code> by the matrix <pre> -1 0 0 0 0 1 0 0 0 0 1 0 </pre>

negateX
Matrix4x3d negateX(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
negateY
Matrix4x3d negateY(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
negateY
Matrix4x3d negateY()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 -1 0 0 0 0 1 0 </pre>

negateZ
Matrix4x3d negateZ(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
negateZ
Matrix4x3d negateZ()

Multiply <code>this</code> by the matrix <pre> 1 0 0 0 0 1 0 0 0 0 -1 0 </pre>

normal
Matrix4x3d normal(Matrix4x3d dest)

Compute a normal matrix from the left 3x3 submatrix of <code>this</code> and store it into the left 3x3 submatrix of <code>dest</code>. All other values of <code>dest</code> will be set to {@link #identity() identity}. <p> The normal matrix of <code>m</code> is the transpose of the inverse of <code>m</code>. <p> Please note that, if <code>this</code> is an orthogonal matrix or a matrix whose columns are orthogonal vectors, then this method <i>need not</i> be invoked, since in that case <code>this</code> itself is its normal matrix. In that case, use {@link #set3x3(Matrix4x3d)} to set a given Matrix4x3d to only the left 3x3 submatrix of a given matrix.

normal
Matrix3d normal(Matrix3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
normal
Matrix4x3d normal()

Compute a normal matrix from the left 3x3 submatrix of <code>this</code> and store it into the left 3x3 submatrix of <code>this</code>. All other values of <code>this</code> will be set to {@link #identity() identity}. <p> The normal matrix of <code>m</code> is the transpose of the inverse of <code>m</code>. <p> Please note that, if <code>this</code> is an orthogonal matrix or a matrix whose columns are orthogonal vectors, then this method <i>need not</i> be invoked, since in that case <code>this</code> itself is its normal matrix. In that case, use {@link #set3x3(Matrix4x3d)} to set a given Matrix4x3d to only the left 3x3 submatrix of this matrix.

normalize3x3
Matrix3d normalize3x3(Matrix3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3
Matrix4x3d normalize3x3(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3
Matrix4x3d normalize3x3()

Normalize the left 3x3 submatrix of this matrix. <p> The resulting matrix will map unit vectors to unit vectors, though a pair of orthogonal input unit vectors need not be mapped to a pair of orthogonal output vectors if the original matrix was not orthogonal itself (i.e. had <i>skewing</i>).

normalizedPositiveX
Vector3d normalizedPositiveX(Vector3d dir)
Undocumented in source. Be warned that the author may not have intended to support it.
normalizedPositiveY
Vector3d normalizedPositiveY(Vector3d dir)
Undocumented in source. Be warned that the author may not have intended to support it.
normalizedPositiveZ
Vector3d normalizedPositiveZ(Vector3d dir)
Undocumented in source. Be warned that the author may not have intended to support it.
obliqueZ
Matrix4x3d obliqueZ(double a, double b, Matrix4x3d dest)

Apply an oblique projection transformation to this matrix with the given values for <code>a</code> and <code>b</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the oblique transformation matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the oblique transformation will be applied first! <p> The oblique transformation is defined as: <pre> x' = x + a*z y' = y + a*z z' = z </pre> or in matrix form: <pre> 1 0 a 0 0 1 b 0 0 0 1 0 </pre>

obliqueZ
Matrix4x3d obliqueZ(double a, double b)

Apply an oblique projection transformation to this matrix with the given values for <code>a</code> and <code>b</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the oblique transformation matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the oblique transformation will be applied first! <p> The oblique transformation is defined as: <pre> x' = x + a*z y' = y + a*z z' = z </pre> or in matrix form: <pre> 1 0 a 0 0 1 b 0 0 0 1 0 </pre>

origin
Vector3d origin(Vector3d origin)
Undocumented in source. Be warned that the author may not have intended to support it.
ortho
Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar)

Apply an orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho
Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

Apply an orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho
Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest)

Apply an orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho
Matrix4x3d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest)

Apply an orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho2D
Matrix4x3d ortho2D(double left, double right, double bottom, double top)

Apply an orthographic projection transformation for a right-handed coordinate system to this matrix. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double) ortho()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2D(double, double, double, double) setOrtho2D()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho2D
Matrix4x3d ortho2D(double left, double right, double bottom, double top, Matrix4x3d dest)

Apply an orthographic projection transformation for a right-handed coordinate system to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4x3d) ortho()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2D(double, double, double, double) setOrtho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho2DLH
Matrix4x3d ortho2DLH(double left, double right, double bottom, double top, Matrix4x3d dest)

Apply an orthographic projection transformation for a left-handed coordinate system to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4x3d) orthoLH()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2DLH(double, double, double, double) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

ortho2DLH
Matrix4x3d ortho2DLH(double left, double right, double bottom, double top)

Apply an orthographic projection transformation for a left-handed coordinate system to this matrix. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double) orthoLH()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrtho2DLH(double, double, double, double) setOrtho2DLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoLH
Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar)

Apply an orthographic projection transformation for a left-handed coordiante system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoLH
Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

Apply an orthographic projection transformation for a left-handed coordiante system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double, bool) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoLH
Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4x3d dest)

Apply an orthographic projection transformation for a left-handed coordiante system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoLH
Matrix4x3d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest)

Apply an orthographic projection transformation for a left-handed coordiante system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to an orthographic projection without post-multiplying it, use {@link #setOrthoLH(double, double, double, double, double, double, bool) setOrthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetric
Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar)

Apply a symmetric orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetric
Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne)

Apply a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, bool) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double, bool) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetric
Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4x3d dest)

Apply a symmetric orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, Matrix4x3d) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetric
Matrix4x3d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest)

Apply a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #ortho(double, double, double, double, double, double, bool, Matrix4x3d) ortho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetric(double, double, double, double, bool) setOrthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetricLH
Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4x3d dest)

Apply a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, bool, Matrix4x3d) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double, bool) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetricLH
Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4x3d dest)

Apply a symmetric orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix and store the result in <code>dest</code>. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, Matrix4x3d) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetricLH
Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne)

Apply a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double, bool) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double, bool) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

orthoSymmetricLH
Matrix4x3d orthoSymmetricLH(double width, double height, double zNear, double zFar)

Apply a symmetric orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> This method is equivalent to calling {@link #orthoLH(double, double, double, double, double, double) orthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>O</code> the orthographic projection matrix, then the new matrix will be <code>M * O</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * O * v</code>, the orthographic projection transformation will be applied first! <p> In order to set the matrix to a symmetric orthographic projection without post-multiplying it, use {@link #setOrthoSymmetricLH(double, double, double, double) setOrthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

pick
Matrix4x3d pick(double x, double y, double width, double height, int[] viewport, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
pick
Matrix4x3d pick(double x, double y, double width, double height, int[] viewport)

Apply a picking transformation to this matrix using the given window coordinates <code>(x, y)</code> as the pick center and the given <code>(width, height)</code> as the size of the picking region in window coordinates.

positiveX
Vector3d positiveX(Vector3d dir)
Undocumented in source. Be warned that the author may not have intended to support it.
positiveY
Vector3d positiveY(Vector3d dir)
Undocumented in source. Be warned that the author may not have intended to support it.
positiveZ
Vector3d positiveZ(Vector3d dir)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4x3d reflect(double a, double b, double c, double d, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4x3d reflect(double a, double b, double c, double d)

Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the equation <code>x*a + y*b + z*c + d = 0</code>. <p> The vector <code>(a, b, c)</code> must be a unit vector. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first! <p> Reference: <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb281733(v=vs.85).aspx">msdn.microsoft.com</a>

reflect
Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz)

Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first!

reflect
Matrix4x3d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4x3d reflect(Vector3d normal, Vector3d point)

Apply a mirror/reflection transformation to this matrix that reflects about the given plane specified via the plane normal and a point on the plane. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first!

reflect
Matrix4x3d reflect(Quaterniond orientation, Vector3d point)

Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation and a point on the plane. <p> This method can be used to build a reflection transformation based on the orientation of a mirror object in the scene. It is assumed that the default mirror plane's normal is <code>(0, 0, 1)</code>. So, if the given {@link Quaterniond} is the identity (does not apply any additional rotation), the reflection plane will be <code>z=0</code>, offset by the given <code>point</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the reflection matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the reflection will be applied first!

reflect
Matrix4x3d reflect(Quaterniond orientation, Vector3d point, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4x3d reflect(Vector3d normal, Vector3d point, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflection
Matrix4x3d reflection(double a, double b, double c, double d)

Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the equation <code>x*a + y*b + z*c + d = 0</code>. <p> The vector <code>(a, b, c)</code> must be a unit vector. <p> Reference: <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb281733(v=vs.85).aspx">msdn.microsoft.com</a>

reflection
Matrix4x3d reflection(double nx, double ny, double nz, double px, double py, double pz)

Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the plane normal and a point on the plane.

reflection
Matrix4x3d reflection(Vector3d normal, Vector3d point)

Set this matrix to a mirror/reflection transformation that reflects about the given plane specified via the plane normal and a point on the plane.

reflection
Matrix4x3d reflection(Quaterniond orientation, Vector3d point)

Set this matrix to a mirror/reflection transformation that reflects about a plane specified via the plane orientation and a point on the plane. <p> This method can be used to build a reflection transformation based on the orientation of a mirror object in the scene. It is assumed that the default mirror plane's normal is <code>(0, 0, 1)</code>. So, if the given {@link Quaterniond} is the identity (does not apply any additional rotation), the reflection plane will be <code>z=0</code>, offset by the given <code>point</code>.

rotate
Matrix4x3d rotate(double angle, Vector3d axis)

Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given angle and axis, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the axis-angle rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(double, Vector3d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotate
Matrix4x3d rotate(AxisAngle4d axisAngle, Matrix4x3d dest)

Apply a rotation transformation, rotating about the given {@link AxisAngle4d} and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given {@link AxisAngle4d}, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the {@link AxisAngle4d} rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotate
Matrix4x3d rotate(AxisAngle4d axisAngle)

Apply a rotation transformation, rotating about the given {@link AxisAngle4d}, to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given {@link AxisAngle4d}, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the {@link AxisAngle4d} rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotate
Matrix4x3d rotate(Quaterniond quat)

Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotate
Matrix4x3d rotate(Quaterniond quat, Matrix4x3d dest)

Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotate
Matrix4x3d rotate(double ang, double x, double y, double z)

Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code> , the rotation will be applied first! <p> In order to set the matrix to a rotation matrix without post-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}.

rotate
Matrix4x3d rotate(double ang, double x, double y, double z, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotate
Matrix4x3d rotate(double angle, Vector3d axis, Matrix4x3d dest)

Apply a rotation transformation, rotating the given radians about the specified axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>A</code> the rotation matrix obtained from the given angle and axis, then the new matrix will be <code>M * A</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * A * v</code>, the axis-angle rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(double, Vector3d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotateAround
Matrix4x3d rotateAround(Quaterniond quat, double ox, double oy, double oz, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateAround
Matrix4x3d rotateAround(Quaterniond quat, double ox, double oy, double oz)

Apply the rotation transformation of the given {@link Quaterniond} to this matrix while using <code>(ox, oy, oz)</code> as the rotation origin. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> This method is equivalent to calling: <code>translate(ox, oy, oz).rotate(quat).translate(-ox, -oy, -oz)</code> <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateLocal
Matrix4x3d rotateLocal(Quaterniond quat)

Pre-multiply the rotation transformation of the given {@link Quaterniond} to this matrix. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>Q * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>Q * M * v</code>, the quaternion rotation will be applied last! <p> In order to set the matrix to a rotation transformation without pre-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateLocal
Matrix4x3d rotateLocal(Quaterniond quat, Matrix4x3d dest)

Pre-multiply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>Q * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>Q * M * v</code>, the quaternion rotation will be applied last! <p> In order to set the matrix to a rotation transformation without pre-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateLocal
Matrix4x3d rotateLocal(double ang, double x, double y, double z)

Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis. <p> The axis described by the three components needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocal
Matrix4x3d rotateLocal(double ang, double x, double y, double z, Matrix4x3d dest)

Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>. <p> The axis described by the three components needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocalX
Matrix4x3d rotateLocalX(double ang)

Pre-multiply a rotation to this matrix by rotating the given amount of radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationX(double) rotationX()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocalX
Matrix4x3d rotateLocalX(double ang, Matrix4x3d dest)

Pre-multiply a rotation around the X axis to this matrix by rotating the given amount of radians about the X axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationX(double) rotationX()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocalY
Matrix4x3d rotateLocalY(double ang)

Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationY(double) rotationY()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocalY
Matrix4x3d rotateLocalY(double ang, Matrix4x3d dest)

Pre-multiply a rotation around the Y axis to this matrix by rotating the given amount of radians about the Y axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationY(double) rotationY()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocalZ
Matrix4x3d rotateLocalZ(double ang)

Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationZ(double) rotationY()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateLocalZ
Matrix4x3d rotateLocalZ(double ang, Matrix4x3d dest)

Pre-multiply a rotation around the Z axis to this matrix by rotating the given amount of radians about the Z axis and store the result in <code>dest</code>. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>R * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>R * M * v</code>, the rotation will be applied last! <p> In order to set the matrix to a rotation matrix without pre-multiplying the rotation transformation, use {@link #rotationZ(double) rotationZ()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateTowards
Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4x3d dest)

Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>(dirX, dirY, dirZ)</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(double, double, double, double, double, double) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert(), dest)</code>

rotateTowards
Matrix4x3d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)

Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>(dirX, dirY, dirZ)</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(double, double, double, double, double, double) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert())</code>

rotateTowards
Matrix4x3d rotateTowards(Vector3d dir, Vector3d up)

Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>dir</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert())</code>

rotateTowards
Matrix4x3d rotateTowards(Vector3d dir, Vector3d up, Matrix4x3d dest)

Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>dir</code> and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the lookat matrix, then the new matrix will be <code>M * L</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * L * v</code>, the lookat transformation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying it, use {@link #rotationTowards(Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mul(new Matrix4x3d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert(), dest)</code>

rotateTranslation
Matrix4x3d rotateTranslation(Quaterniond quat, Matrix4x3d dest)

Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix, which is assumed to only contain a translation, and store the result in <code>dest</code>. <p> This method assumes <code>this</code> to only contain a translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>Q</code> the rotation matrix obtained from the given quaternion, then the new matrix will be <code>M * Q</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * Q * v</code>, the quaternion rotation will be applied first! <p> In order to set the matrix to a rotation transformation without post-multiplying, use {@link #rotation(Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateTranslation
Matrix4x3d rotateTranslation(double ang, double x, double y, double z, Matrix4x3d dest)

Apply rotation to this matrix, which is assumed to only contain a translation, by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis and store the result in <code>dest</code>. <p> This method assumes <code>this</code> to only contain a translation. <p> The axis described by the three components needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> In order to set the matrix to a rotation matrix without post-multiplying the rotation transformation, use {@link #rotation(double, double, double, double) rotation()}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">http://en.wikipedia.org</a>

rotateX
Matrix4x3d rotateX(double ang)

Apply rotation about the X axis to this matrix by rotating the given amount of radians. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>

rotateX
Matrix4x3d rotateX(double ang, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ
Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ
Matrix4x3d rotateXYZ(double angleX, double angleY, double angleZ)

Apply rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateX(angleX).rotateY(angleY).rotateZ(angleZ)</code>

rotateXYZ
Matrix4x3d rotateXYZ(Vector3d angles)

Apply rotation of <code>angles.x</code> radians about the X axis, followed by a rotation of <code>angles.y</code> radians about the Y axis and followed by a rotation of <code>angles.z</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateX(angles.x).rotateY(angles.y).rotateZ(angles.z)</code>

rotateY
Matrix4x3d rotateY(double ang)

Apply rotation about the Y axis to this matrix by rotating the given amount of radians. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>

rotateY
Matrix4x3d rotateY(double ang, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ
Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ
Matrix4x3d rotateYXZ(double angleY, double angleX, double angleZ)

Apply rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateY(angleY).rotateX(angleX).rotateZ(angleZ)</code>

rotateYXZ
Matrix4x3d rotateYXZ(Vector3d angles)

Apply rotation of <code>angles.y</code> radians about the Y axis, followed by a rotation of <code>angles.x</code> radians about the X axis and followed by a rotation of <code>angles.z</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateY(angles.y).rotateX(angles.x).rotateZ(angles.z)</code>

rotateZ
Matrix4x3d rotateZ(double ang)

Apply rotation about the Z axis to this matrix by rotating the given amount of radians. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>

rotateZ
Matrix4x3d rotateZ(double ang, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX
Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX
Matrix4x3d rotateZYX(double angleZ, double angleY, double angleX)

Apply rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleX</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateZ(angleZ).rotateY(angleY).rotateX(angleX)</code>

rotateZYX
Matrix4x3d rotateZYX(Vector3d angles)

Apply rotation of <code>angles.z</code> radians about the Z axis, followed by a rotation of <code>angles.y</code> radians about the Y axis and followed by a rotation of <code>angles.x</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the rotation matrix, then the new matrix will be <code>M * R</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * R * v</code>, the rotation will be applied first! <p> This method is equivalent to calling: <code>rotateZ(angles.z).rotateY(angles.y).rotateX(angles.x)</code>

rotation
Matrix4x3d rotation(Quaterniond quat)

Set this matrix to the rotation - and possibly scaling - transformation of the given {@link Quaterniond}. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation. <p> In order to apply the rotation transformation to an existing transformation, use {@link #rotate(Quaterniond) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotation
Matrix4x3d rotation(AxisAngle4d angleAxis)

Set this matrix to a rotation transformation using the given {@link AxisAngle4d}. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation. <p> In order to apply the rotation transformation to an existing transformation, use {@link #rotate(AxisAngle4d) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotation
Matrix4x3d rotation(double angle, Vector3d axis)

Set this matrix to a rotation matrix which rotates the given radians about a given axis. <p> The axis described by the <code>axis</code> vector needs to be a unit vector. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

rotation
Matrix4x3d rotation(double angle, double x, double y, double z)

Set this matrix to a rotation matrix which rotates the given radians about a given axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> From <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle">Wikipedia</a>

rotationAround
Matrix4x3d rotationAround(Quaterniond quat, double ox, double oy, double oz)

Set this matrix to a transformation composed of a rotation of the specified {@link Quaterniond} while using <code>(ox, oy, oz)</code> as the rotation origin. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(ox, oy, oz).rotate(quat).translate(-ox, -oy, -oz)</code> <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotationTowards
Matrix4x3d rotationTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)

Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local <code>-z</code> axis with <code>(dirX, dirY, dirZ)</code>. <p> In order to apply the rotation transformation to a previous existing transformation, use {@link #rotateTowards(double, double, double, double, double, double) rotateTowards}. <p> This method is equivalent to calling: <code>setLookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invert()</code>

rotationTowards
Matrix4x3d rotationTowards(Vector3d dir, Vector3d up)

Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local <code>-z</code> axis with <code>dir</code>. <p> In order to apply the rotation transformation to a previous existing transformation, use {@link #rotateTowards(double, double, double, double, double, double) rotateTowards}. <p> This method is equivalent to calling: <code>setLookAt(new Vector3d(), new Vector3d(dir).negate(), up).invert()</code>

rotationX
Matrix4x3d rotationX(double ang)

Set this matrix to a rotation transformation about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>

rotationXYZ
Matrix4x3d rotationXYZ(double angleX, double angleY, double angleZ)

Set this matrix to a rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>rotationX(angleX).rotateY(angleY).rotateZ(angleZ)</code>

rotationY
Matrix4x3d rotationY(double ang)

Set this matrix to a rotation transformation about the Y axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>

rotationYXZ
Matrix4x3d rotationYXZ(double angleY, double angleX, double angleZ)

Set this matrix to a rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>rotationY(angleY).rotateX(angleX).rotateZ(angleZ)</code>

rotationZ
Matrix4x3d rotationZ(double ang)

Set this matrix to a rotation transformation about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">http://en.wikipedia.org</a>

rotationZYX
Matrix4x3d rotationZYX(double angleZ, double angleY, double angleX)

Set this matrix to a rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleX</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>rotationZ(angleZ).rotateY(angleY).rotateX(angleX)</code>

scale
Matrix4x3d scale(double xyz)

Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code> , the scaling will be applied first!

scale
Matrix4x3d scale(double xyz, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scale
Matrix4x3d scale(double x, double y, double z)

Apply scaling to <code>this</code> matrix by scaling the base axes by the given x, y and z factors. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code> , the scaling will be applied first!

scale
Matrix4x3d scale(double x, double y, double z, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scale
Matrix4x3d scale(Vector3d xyz)

Apply scaling to this matrix by scaling the base axes by the given <code>xyz.x</code>, <code>xyz.y</code> and <code>xyz.z</code> factors, respectively. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first!

scale
Matrix4x3d scale(Vector3d xyz, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleAround
Matrix4x3d scaleAround(double factor, double ox, double oy, double oz, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleAround
Matrix4x3d scaleAround(double factor, double ox, double oy, double oz)

Apply scaling to this matrix by scaling all three base axes by the given <code>factor</code> while using <code>(ox, oy, oz)</code> as the scaling origin. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first! <p> This method is equivalent to calling: <code>translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz)</code>

scaleAround
Matrix4x3d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz)

Apply scaling to this matrix by scaling the base axes by the given sx, sy and sz factors while using <code>(ox, oy, oz)</code> as the scaling origin. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first! <p> This method is equivalent to calling: <code>translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz)</code>

scaleAround
Matrix4x3d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal
Matrix4x3d scaleLocal(double x, double y, double z)

Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>S * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>S * M * v</code>, the scaling will be applied last!

scaleLocal
Matrix4x3d scaleLocal(double x, double y, double z, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleXY
Matrix4x3d scaleXY(double x, double y)

Apply scaling to this matrix by scaling the X axis by <code>x</code> and the Y axis by <code>y</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the scaling matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the scaling will be applied first!

scaleXY
Matrix4x3d scaleXY(double x, double y, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaling
Matrix4x3d scaling(Vector3d xyz)

Set this matrix to be a simple scale matrix which scales the base axes by <code>xyz.x</code>, <code>xyz.y</code> and <code>xyz.z</code>, respectively. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling. <p> In order to post-multiply a scaling transformation directly to a matrix use {@link #scale(Vector3d) scale()} instead.

scaling
Matrix4x3d scaling(double x, double y, double z)

Set this matrix to be a simple scale matrix.

scaling
Matrix4x3d scaling(double factor)

Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given factor. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling. <p> In order to post-multiply a scaling transformation directly to a matrix, use {@link #scale(double) scale()} instead.

set
Matrix4x3d set(Vector3d col0, Vector3d col1, Vector3d col2, Vector3d col3)

Set the four columns of this matrix to the supplied vectors, respectively.

set
Matrix4x3d set(double[] m)

Set the values in the matrix using a double array that contains the matrix elements in column-major order. <p> The results will look like this:<br><br>

set
Matrix4x3d set(double[] m, int off)

Set the values in the matrix using a double array that contains the matrix elements in column-major order. <p> The results will look like this:<br><br>

set
Matrix4x3d set(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32)

Set the values within this matrix to the supplied double values. The matrix will look like this:<br><br>

set
Matrix4x3d set(Matrix4x3d m)

Store the values of the given matrix <code>m</code> into <code>this</code> matrix.

set
Matrix4x3d set(Matrix4d m)

Store the values of the upper 4x3 submatrix of <code>m</code> into <code>this</code> matrix.

set
Matrix4x3d set(Matrix3d mat)

Set the left 3x3 submatrix of this {@link Matrix4x3d} to the given {@link Matrix3d} and the rest to identity.

set
Matrix4x3d set(Quaterniond q)

Set this matrix to be equivalent to the rotation - and possibly scaling - specified by the given {@link Quaterniond}. <p> This method is equivalent to calling: <code>rotation(q)</code>

set
Matrix4x3d set(AxisAngle4d axisAngle)

Set this matrix to be equivalent to the rotation specified by the given {@link AxisAngle4d}.

set3x3
Matrix4x3d set3x3(Matrix4x3d mat)

Set the left 3x3 submatrix of this {@link Matrix4x3d} to that of the given {@link Matrix4x3d} and don't change the other elements.

set3x3
Matrix4x3d set3x3(Matrix3d mat)

Set the left 3x3 submatrix of this {@link Matrix4x3d} to the given {@link Matrix3d} and don't change the other elements.

setColumn
Matrix4x3d setColumn(int column, Vector3d src)

Set the column at the given <code>column</code> index, starting with <code>0</code>.

setLookAlong
Matrix4x3d setLookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)

Set this matrix to a rotation transformation to make <code>-z</code> point along <code>dir</code>. <p> This is equivalent to calling {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to apply the lookalong transformation to any previous existing transformation, use {@link #lookAlong(double, double, double, double, double, double) lookAlong()}

setLookAlong
Matrix4x3d setLookAlong(Vector3d dir, Vector3d up)

Set this matrix to a rotation transformation to make <code>-z</code> point along <code>dir</code>. <p> This is equivalent to calling {@link #setLookAt(Vector3d, Vector3d, Vector3d) setLookAt()} with <code>eye = (0, 0, 0)</code> and <code>center = dir</code>. <p> In order to apply the lookalong transformation to any previous existing transformation, use {@link #lookAlong(Vector3d, Vector3d)}.

setLookAt
Matrix4x3d setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)

Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAt(double, double, double, double, double, double, double, double, double) lookAt}.

setLookAt
Matrix4x3d setLookAt(Vector3d eye, Vector3d center, Vector3d up)

Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns <code>-z</code> with <code>center - eye</code>. <p> In order to not make use of vectors to specify <code>eye</code>, <code>center</code> and <code>up</code> but use primitives, like in the GLU function, use {@link #setLookAt(double, double, double, double, double, double, double, double, double) setLookAt()} instead. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAt(Vector3d, Vector3d, Vector3d) lookAt()}.

setLookAtLH
Matrix4x3d setLookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)

Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAtLH(double, double, double, double, double, double, double, double, double) lookAtLH}.

setLookAtLH
Matrix4x3d setLookAtLH(Vector3d eye, Vector3d center, Vector3d up)

Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns <code>+z</code> with <code>center - eye</code>. <p> In order to not make use of vectors to specify <code>eye</code>, <code>center</code> and <code>up</code> but use primitives, like in the GLU function, use {@link #setLookAtLH(double, double, double, double, double, double, double, double, double) setLookAtLH()} instead. <p> In order to apply the lookat transformation to a previous existing transformation, use {@link #lookAtLH(Vector3d, Vector3d, Vector3d) lookAt()}.

setOrtho
Matrix4x3d setOrtho(double left, double right, double bottom, double top, double zNear, double zFar)

Set this matrix to be an orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho(double, double, double, double, double, double) ortho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrtho
Matrix4x3d setOrtho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be an orthographic projection transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho(double, double, double, double, double, double, bool) ortho()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrtho2D
Matrix4x3d setOrtho2D(double left, double right, double bottom, double top)

Set this matrix to be an orthographic projection transformation for a right-handed coordinate system. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double) setOrtho()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho2D(double, double, double, double) ortho2D()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrtho2DLH
Matrix4x3d setOrtho2DLH(double left, double right, double bottom, double top)

Set this matrix to be an orthographic projection transformation for a left-handed coordinate system. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double) setOrthoLH()} with <code>zNear=-1</code> and <code>zFar=+1</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #ortho2DLH(double, double, double, double) ortho2DLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrthoLH
Matrix4x3d setOrthoLH(double left, double right, double bottom, double top, double zNear, double zFar)

Set this matrix to be an orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #orthoLH(double, double, double, double, double, double) orthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrthoLH
Matrix4x3d setOrthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be an orthographic projection transformation for a left-handed coordinate system using the given NDC z range. <p> In order to apply the orthographic projection to an already existing transformation, use {@link #orthoLH(double, double, double, double, double, double, bool) orthoLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrthoSymmetric
Matrix4x3d setOrthoSymmetric(double width, double height, double zNear, double zFar)

Set this matrix to be a symmetric orthographic projection transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double) setOrtho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetric(double, double, double, double) orthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrthoSymmetric
Matrix4x3d setOrthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetric(double, double, double, double, bool) orthoSymmetric()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrthoSymmetricLH
Matrix4x3d setOrthoSymmetricLH(double width, double height, double zNear, double zFar)

Set this matrix to be a symmetric orthographic projection transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> This method is equivalent to calling {@link #setOrthoLH(double, double, double, double, double, double) setOrthoLH()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetricLH(double, double, double, double) orthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setOrthoSymmetricLH
Matrix4x3d setOrthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range. <p> This method is equivalent to calling {@link #setOrtho(double, double, double, double, double, double, bool) setOrtho()} with <code>left=-width/2</code>, <code>right=+width/2</code>, <code>bottom=-height/2</code> and <code>top=+height/2</code>. <p> In order to apply the symmetric orthographic projection to an already existing transformation, use {@link #orthoSymmetricLH(double, double, double, double, bool) orthoSymmetricLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho">http://www.songho.ca</a>

setRotationXYZ
Matrix4x3d setRotationXYZ(double angleX, double angleY, double angleZ)

Set only the left 3x3 submatrix of this matrix to a rotation of <code>angleX</code> radians about the X axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

setRotationYXZ
Matrix4x3d setRotationYXZ(double angleY, double angleX, double angleZ)

Set only the left 3x3 submatrix of this matrix to a rotation of <code>angleY</code> radians about the Y axis, followed by a rotation of <code>angleX</code> radians about the X axis and followed by a rotation of <code>angleZ</code> radians about the Z axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

setRotationZYX
Matrix4x3d setRotationZYX(double angleZ, double angleY, double angleX)

Set only the left 3x3 submatrix of this matrix to a rotation of <code>angleZ</code> radians about the Z axis, followed by a rotation of <code>angleY</code> radians about the Y axis and followed by a rotation of <code>angleX</code> radians about the X axis. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.

setRow
Matrix4x3d setRow(int row, Vector4d src)

Set the row at the given <code>row</code> index, starting with <code>0</code>.

setTranslation
Matrix4x3d setTranslation(Vector3d xyz)

Set only the translation components <code>(m30, m31, m32)</code> of this matrix to the given values <code>(xyz.x, xyz.y, xyz.z)</code>. <p> To build a translation matrix instead, use {@link #translation(Vector3d)}. To apply a translation, use {@link #translate(Vector3d)}.

setTranslation
Matrix4x3d setTranslation(double x, double y, double z)

Set only the translation components <code>(m30, m31, m32)</code> of this matrix to the given values <code>(x, y, z)</code>. <p> To build a translation matrix instead, use {@link #translation(double, double, double)}. To apply a translation, use {@link #translate(double, double, double)}.

setm00
Matrix4x3d setm00(double m00)

Set the value of the matrix element at column 0 and row 0.

setm01
Matrix4x3d setm01(double m01)

Set the value of the matrix element at column 0 and row 1.

setm02
Matrix4x3d setm02(double m02)

Set the value of the matrix element at column 0 and row 2.

setm10
Matrix4x3d setm10(double m10)

Set the value of the matrix element at column 1 and row 0.

setm11
Matrix4x3d setm11(double m11)

Set the value of the matrix element at column 1 and row 1.

setm12
Matrix4x3d setm12(double m12)

Set the value of the matrix element at column 1 and row 2.

setm20
Matrix4x3d setm20(double m20)

Set the value of the matrix element at column 2 and row 0.

setm21
Matrix4x3d setm21(double m21)

Set the value of the matrix element at column 2 and row 1.

setm22
Matrix4x3d setm22(double m22)

Set the value of the matrix element at column 2 and row 2.

setm30
Matrix4x3d setm30(double m30)

Set the value of the matrix element at column 3 and row 0.

setm31
Matrix4x3d setm31(double m31)

Set the value of the matrix element at column 3 and row 1.

setm32
Matrix4x3d setm32(double m32)

Set the value of the matrix element at column 3 and row 2.

shadow
Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3d planeTransform)

Apply a projection transformation to this matrix that projects onto the plane with the general plane equation <code>y = 0</code> as if casting a shadow from a given light position/direction <code>(lightX, lightY, lightZ, lightW)</code>. <p> Before the shadow projection is applied, the plane is transformed via the specified <code>planeTransformation</code>. <p> If <code>lightW</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first!

shadow
Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4x3d planeTransform, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4x3d shadow(Vector4d light, Matrix4x3d planeTransform)

Apply a projection transformation to this matrix that projects onto the plane with the general plane equation <code>y = 0</code> as if casting a shadow from a given light position/direction <code>light</code>. <p> Before the shadow projection is applied, the plane is transformed via the specified <code>planeTransformation</code>. <p> If <code>light.w</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first!

shadow
Matrix4x3d shadow(Vector4d light, Matrix4x3d planeTransform, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4x3d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d)

Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation <code>x*a + y*b + z*c + d = 0</code> as if casting a shadow from a given light position/direction <code>(lightX, lightY, lightZ, lightW)</code>. <p> If <code>lightW</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first! <p> Reference: <a href="ftp://ftp.sgi.com/opengl/contrib/blythe/advanced99/notes/node192.html">ftp.sgi.com</a>

shadow
Matrix4x3d shadow(Vector4d light, double a, double b, double c, double d, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4x3d shadow(Vector4d light, double a, double b, double c, double d)

Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation <code>x*a + y*b + z*c + d = 0</code> as if casting a shadow from a given light position/direction <code>light</code>. <p> If <code>light.w</code> is <code>0.0</code> the light is being treated as a directional light; if it is <code>1.0</code> it is a point light. <p> If <code>M</code> is <code>this</code> matrix and <code>S</code> the shadow matrix, then the new matrix will be <code>M * S</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * S * v</code>, the shadow projection will be applied first! <p> Reference: <a href="ftp://ftp.sgi.com/opengl/contrib/blythe/advanced99/notes/node192.html">ftp.sgi.com</a>

sub
Matrix4x3d sub(Matrix4x3d subtrahend, Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
sub
Matrix4x3d sub(Matrix4x3d subtrahend)

Component-wise subtract <code>subtrahend</code> from <code>this</code>.

swap
Matrix4x3d swap(Matrix4x3d other)

Exchange the values of <code>this</code> matrix with the given <code>other</code> matrix.

transform
Vector4d transform(Vector4d v, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transform
Vector4d transform(Vector4d v)
Undocumented in source. Be warned that the author may not have intended to support it.
transformAab
Matrix4x3d transformAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ, Vector3d outMin, Vector3d outMax)
Undocumented in source. Be warned that the author may not have intended to support it.
transformAab
Matrix4x3d transformAab(Vector3d min, Vector3d max, Vector3d outMin, Vector3d outMax)
Undocumented in source. Be warned that the author may not have intended to support it.
transformDirection
Vector3d transformDirection(Vector3d v, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformDirection
Vector3d transformDirection(Vector3d v)
Undocumented in source. Be warned that the author may not have intended to support it.
transformPosition
Vector3d transformPosition(Vector3d v, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformPosition
Vector3d transformPosition(Vector3d v)
Undocumented in source. Be warned that the author may not have intended to support it.
translate
Matrix4x3d translate(double x, double y, double z)

Apply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(double, double, double)}.

translate
Matrix4x3d translate(double x, double y, double z, Matrix4x3d dest)

Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(double, double, double)}.

translate
Matrix4x3d translate(Vector3d offset, Matrix4x3d dest)

Apply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(Vector3d)}.

translate
Matrix4x3d translate(Vector3d offset)

Apply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>M * T</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * T * v</code>, the translation will be applied first! <p> In order to set the matrix to a translation transformation without post-multiplying it, use {@link #translation(Vector3d)}.

translateLocal
Matrix4x3d translateLocal(double x, double y, double z)

Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(double, double, double)}.

translateLocal
Matrix4x3d translateLocal(double x, double y, double z, Matrix4x3d dest)

Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(double, double, double)}.

translateLocal
Matrix4x3d translateLocal(Vector3d offset, Matrix4x3d dest)

Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z and store the result in <code>dest</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(Vector3d)}.

translateLocal
Matrix4x3d translateLocal(Vector3d offset)

Pre-multiply a translation to this matrix by translating by the given number of units in x, y and z. <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the translation matrix, then the new matrix will be <code>T * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>T * M * v</code>, the translation will be applied last! <p> In order to set the matrix to a translation transformation without pre-multiplying it, use {@link #translation(Vector3d)}.

translation
Matrix4x3d translation(Vector3d offset)

Set this matrix to be a simple translation matrix. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional translation.

translation
Matrix4x3d translation(double x, double y, double z)

Set this matrix to be a simple translation matrix. <p> The resulting matrix can be multiplied against another transformation matrix to obtain an additional translation.

translationRotate
Matrix4x3d translationRotate(Vector3d translation, Quaterniond quat)

Set <code>this</code> matrix to <code>T * R</code>, where <code>T</code> is the given <code>translation</code> and <code>R</code> is a rotation transformation specified by the given quaternion. <p> When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(translation).rotate(quat)</code>

translationRotate
Matrix4x3d translationRotate(double tx, double ty, double tz, double qx, double qy, double qz, double qw)

Set <code>this</code> matrix to <code>T * R</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code> and <code>R</code> is a rotation - and possibly scaling - transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>. <p> When transforming a vector by the resulting matrix the rotation - and possibly scaling - transformation will be applied first and then the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat)</code>

translationRotate
Matrix4x3d translationRotate(double tx, double ty, double tz, Quaterniond quat)

Set <code>this</code> matrix to <code>T * R</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code> and <code>R</code> is a rotation transformation specified by the given quaternion. <p> When transforming a vector by the resulting matrix the rotation transformation will be applied first and then the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat)</code>

translationRotateInvert
Matrix4x3d translationRotateInvert(Vector3d translation, Quaterniond quat)

Set <code>this</code> matrix to <code>(T * R)<sup>-1</sup></code>, where <code>T</code> is the given <code>translation</code> and <code>R</code> is a rotation transformation specified by the given quaternion. <p> This method is equivalent to calling: <code>translationRotate(...).invert()</code>

translationRotateInvert
Matrix4x3d translationRotateInvert(double tx, double ty, double tz, double qx, double qy, double qz, double qw)

Set <code>this</code> matrix to <code>(T * R)<sup>-1</sup></code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code> and <code>R</code> is a rotation transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>. <p> This method is equivalent to calling: <code>translationRotate(...).invert()</code>

translationRotateMul
Matrix4x3d translationRotateMul(double tx, double ty, double tz, double qx, double qy, double qz, double qw, Matrix4x3d mat)

Set <code>this</code> matrix to <code>T * R * M</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code>, <code>R</code> is a rotation - and possibly scaling - transformation specified by the quaternion <code>(qx, qy, qz, qw)</code> and <code>M</code> is the given matrix <code>mat</code> <p> When transforming a vector by the resulting matrix the transformation described by <code>M</code> will be applied first, then the scaling, then rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat).mul(mat)</code>

translationRotateScale
Matrix4x3d translationRotateScale(Vector3d translation, Quaterniond quat, Vector3d scale)

Set <code>this</code> matrix to <code>T * R * S</code>, where <code>T</code> is the given <code>translation</code>, <code>R</code> is a rotation transformation specified by the given quaternion, and <code>S</code> is a scaling transformation which scales the axes by <code>scale</code>. <p> When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(translation).rotate(quat).scale(scale)</code>

translationRotateScale
Matrix4x3d translationRotateScale(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz)

Set <code>this</code> matrix to <code>T * R * S</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code>, <code>R</code> is a rotation transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>, and <code>S</code> is a scaling transformation which scales the three axes x, y and z by <code>(sx, sy, sz)</code>. <p> When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat).scale(sx, sy, sz)</code>

translationRotateScaleMul
Matrix4x3d translationRotateScaleMul(Vector3d translation, Quaterniond quat, Vector3d scale, Matrix4x3d m)

Set <code>this</code> matrix to <code>T * R * S * M</code>, where <code>T</code> is the given <code>translation</code>, <code>R</code> is a rotation transformation specified by the given quaternion, <code>S</code> is a scaling transformation which scales the axes by <code>scale</code>. <p> When transforming a vector by the resulting matrix the transformation described by <code>M</code> will be applied first, then the scaling, then rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(translation).rotate(quat).scale(scale).mul(m)</code>

translationRotateScaleMul
Matrix4x3d translationRotateScaleMul(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz, Matrix4x3d m)

Set <code>this</code> matrix to <code>T * R * S * M</code>, where <code>T</code> is a translation by the given <code>(tx, ty, tz)</code>, <code>R</code> is a rotation transformation specified by the quaternion <code>(qx, qy, qz, qw)</code>, <code>S</code> is a scaling transformation which scales the three axes x, y and z by <code>(sx, sy, sz)</code>. <p> When transforming a vector by the resulting matrix the transformation described by <code>M</code> will be applied first, then the scaling, then rotation and at last the translation. <p> When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise. <p> This method is equivalent to calling: <code>translation(tx, ty, tz).rotate(quat).scale(sx, sy, sz).mul(m)</code>

translationRotateTowards
Matrix4x3d translationRotateTowards(Vector3d pos, Vector3d dir, Vector3d up)

Set this matrix to a model transformation for a right-handed coordinate system, that translates to the given <code>pos</code> and aligns the local <code>-z</code> axis with <code>dir</code>. <p> This method is equivalent to calling: <code>translation(pos).rotateTowards(dir, up)</code>

translationRotateTowards
Matrix4x3d translationRotateTowards(double posX, double posY, double posZ, double dirX, double dirY, double dirZ, double upX, double upY, double upZ)

Set this matrix to a model transformation for a right-handed coordinate system, that translates to the given <code>(posX, posY, posZ)</code> and aligns the local <code>-z</code> axis with <code>(dirX, dirY, dirZ)</code>. <p> This method is equivalent to calling: <code>translation(posX, posY, posZ).rotateTowards(dirX, dirY, dirZ, upX, upY, upZ)</code>

transpose3x3
Matrix3d transpose3x3(Matrix3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transpose3x3
Matrix4x3d transpose3x3(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transpose3x3
Matrix4x3d transpose3x3()

Transpose only the left 3x3 submatrix of this matrix and set the rest of the matrix elements to identity.

zero
Matrix4x3d zero()

Set all the values within this matrix to 0.

Static variables

PLANE_NX
int PLANE_NX;

Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>x=-1</code> when using the identity matrix.

PLANE_NY
int PLANE_NY;

Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>y=-1</code> when using the identity matrix.

PLANE_NZ
int PLANE_NZ;

Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>z=-1</code> when using the identity matrix.

PLANE_PX
int PLANE_PX;

Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>x=1</code> when using the identity matrix.

PLANE_PY
int PLANE_PY;

Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>y=1</code> when using the identity matrix.

PLANE_PZ
int PLANE_PZ;

Argument to the first parameter of {@link #frustumPlane(int, Vector4d)} identifying the plane with equation <code>z=1</code> when using the identity matrix.

PROPERTY_IDENTITY
byte PROPERTY_IDENTITY;

Bit returned by {@link #properties()} to indicate that the matrix represents the identity transformation.

PROPERTY_ORTHONORMAL
byte PROPERTY_ORTHONORMAL;

Bit returned by {@link #properties()} to indicate that the left 3x3 submatrix represents an orthogonal matrix (i.e. orthonormal basis).

PROPERTY_TRANSLATION
byte PROPERTY_TRANSLATION;

Bit returned by {@link #properties()} to indicate that the matrix represents a pure translation transformation.

Variables

m00
double m00;
Undocumented in source.
m01
double m01;
Undocumented in source.
m02
double m02;
Undocumented in source.
m10
double m10;
Undocumented in source.
m11
double m11;
Undocumented in source.
m12
double m12;
Undocumented in source.
m20
double m20;
Undocumented in source.
m21
double m21;
Undocumented in source.
m22
double m22;
Undocumented in source.
m30
double m30;
Undocumented in source.
m31
double m31;
Undocumented in source.
m32
double m32;
Undocumented in source.
properties
int properties;
Undocumented in source.

Meta