Matrix4d

Contains the definition of a 4x4 Matrix 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> m03 m13 m23 m33<br>

@author Richard Greenlees @author Kai Burjack

struct Matrix4d {}

Constructors

this
this(Matrix4d mat)

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

this
this(Matrix4x3d mat)

Create a new {@link Matrix4d} and set its upper 4x3 submatrix to the given matrix <code>mat</code> and all other elements to identity.

this
this(Matrix3d mat)

Create a new {@link Matrix4d} by setting its uppper 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 m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33)

Create a new 4x4 matrix using the supplied double values. <p> The matrix layout will be:<br><br> m00, m10, m20, m30<br> m01, m11, m21, m31<br> m02, m12, m22, m32<br> m03, m13, m23, m33

this
this(Vector4d col0, Vector4d col1, Vector4d col2, Vector4d col3)

Create a new {@link Matrix4d} and initialize its four columns using the supplied vectors.

Members

Functions

_m00
Matrix4d _m00(double m00)

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

_m01
Matrix4d _m01(double m01)

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

_m02
Matrix4d _m02(double m02)

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

_m03
Matrix4d _m03(double m03)

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

_m10
Matrix4d _m10(double m10)

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

_m11
Matrix4d _m11(double m11)

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

_m12
Matrix4d _m12(double m12)

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

_m13
Matrix4d _m13(double m13)

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

_m20
Matrix4d _m20(double m20)

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

_m21
Matrix4d _m21(double m21)

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

_m22
Matrix4d _m22(double m22)

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

_m23
Matrix4d _m23(double m23)

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

_m30
Matrix4d _m30(double m30)

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

_m31
Matrix4d _m31(double m31)

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

_m32
Matrix4d _m32(double m32)

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

_m33
Matrix4d _m33(double m33)

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

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

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

add4x3
Matrix4d add4x3(Matrix4d other, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
add4x3
Matrix4d add4x3(Matrix4d other)

Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code>.

affineSpan
Matrix4d affineSpan(Vector3d corner, Vector3d xDir, Vector3d yDir, Vector3d zDir)

Compute the extents of the coordinate system before this {@link #isAffine() affine} transformation was applied and store the resulting corner coordinates in <code>corner</code> and the span vectors in <code>xDir</code>, <code>yDir</code> and <code>zDir</code>. <p> That means, given the maximum extents of the coordinate system between <code>[-1..+1]</code> in all dimensions, this method returns one corner and the length and direction of the three base axis vectors in the coordinate system before this transformation is applied, which transforms into the corner coordinates <code>[-1, +1]</code>. <p> This method is equivalent to computing at least three adjacent corners using {@link #frustumCorner(int, Vector3d)} and subtracting them to obtain the length and direction of the span vectors.

arcball
Matrix4d arcball(double radius, double centerX, double centerY, double centerZ, double angleX, double angleY, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
arcball
Matrix4d arcball(double radius, Vector3d center, double angleX, double angleY, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
arcball
Matrix4d 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
Matrix4d 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>

assume
Matrix4d assume(int properties)

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

billboardCylindrical
Matrix4d 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
Matrix4d 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(ref Vector3d, Vector3d)}.

billboardSpherical
Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.

cofactor3x3
Matrix4d cofactor3x3()

Compute the cofactor matrix of the upper 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.

cofactor3x3
Matrix3d cofactor3x3(Matrix3d dest)

Compute the cofactor matrix of the upper 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
Matrix4d cofactor3x3(Matrix4d dest)

Compute the cofactor matrix of the upper 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(Matrix4d)} 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.
determinant3x3
double determinant3x3()
Undocumented in source. Be warned that the author may not have intended to support it.
determinantAffine
double determinantAffine()
Undocumented in source. Be warned that the author may not have intended to support it.
determineProperties
Matrix4d determineProperties()

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

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

Component-wise add the upper 4x3 submatrices of <code>this</code> and <code>other</code> by first multiplying each component of <code>other</code>'s 4x3 submatrix by <code>otherFactor</code> and adding that result to <code>this</code>. <p> The matrix <code>other</code> will not be changed.

frustum
Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)

Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double, bool) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>

frustum
Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest)

Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>

frustum
Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double, bool) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>

frustum
Matrix4d frustum(double left, double right, double bottom, double top, double zNear, double zFar)

Apply an arbitrary perspective projection frustum 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>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustum(double, double, double, double, double, double) setFrustum()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>

frustumAabb
Matrix4d frustumAabb(Vector3d min, Vector3d max)

Compute the axis-aligned bounding box of the frustum described by <code>this</code> matrix and store the minimum corner coordinates in the given <code>min</code> and the maximum corner coordinates in the given <code>max</code> vector. <p> The matrix <code>this</code> is assumed to be the {@link #invert() inverse} of the origial view-projection matrix for which to compute the axis-aligned bounding box in world-space. <p> The axis-aligned bounding box of the unit frustum is <code>(-1, -1, -1)</code>, <code>(1, 1, 1)</code>.

frustumCorner
Vector3d frustumCorner(int corner, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
frustumLH
Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)

Apply an arbitrary perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double, bool) setFrustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>

frustumLH
Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

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

frustumLH
Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d dest)

Apply an arbitrary perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>F</code> the frustum matrix, then the new matrix will be <code>M * F</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * F * v</code>, the frustum transformation will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setFrustumLH(double, double, double, double, double, double) setFrustumLH()}. <p> Reference: <a href="http://www.songho.ca/opengl/gl_projectionmatrix.html#perspective">http://www.songho.ca</a>

frustumLH
Matrix4d frustumLH(double left, double right, double bottom, double top, double zNear, double zFar)

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

frustumPlane
Vector4d frustumPlane(int plane, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
frustumRayDir
Vector3d frustumRayDir(double x, double y, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
get
Matrix4d get(Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
get
double get(int column, int row)
Undocumented in source. Be warned that the author may not have intended to support it.
get
double[] get(double[] dest)
Undocumented in source. Be warned that the author may not have intended to support it.
get
double[] get(double[] dest, int offset)
Undocumented in source. Be warned that the author may not have intended to support it.
get3x3
Matrix3d get3x3(Matrix3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
get4x3
Matrix4x3d get4x3(Matrix4x3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
getColumn
Vector4d getColumn(int column, Vector4d dest)
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.
getDoubleArray
double[16] getDoubleArray(double[16] dest, int offset)
Undocumented in source. Be warned that the author may not have intended to support it.
getDoubleArray
double[16] getDoubleArray()
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.
getProperties
int getProperties()
Undocumented in source. Be warned that the author may not have intended to support it.
getRow
Vector3d getRow(int row, Vector3d 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.
getRowColumn
double getRowColumn(int row, int column)
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.
getUnnormalizedRotation
Quaterniond getUnnormalizedRotation(Quaterniond dest)
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
Matrix4d 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 #perspective(double, double, double, double) perspective}, {@link #frustum(double, double, double, double, double, double) frustum}, {@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 #setPerspective(double, double, double, double) setPerspective}, {@link #setFrustum(double, double, double, double, double, double) setFrustum}, {@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
Matrix4d invert()

Invert this matrix. <p> If <code>this</code> matrix represents an {@link #isAffine() affine} transformation, such as translation, rotation, scaling and shearing, and thus its last row is equal to <code>(0, 0, 0, 1)</code>, then {@link #invertAffine()} can be used instead of this method.

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

Invert this matrix by assuming that it is an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>).

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

If <code>this</code> is an arbitrary perspective projection matrix obtained via one of the {@link #frustum(double, double, double, double, double, double) frustum()} methods or via {@link #setFrustum(double, double, double, double, double, double) setFrustum()}, then this method builds the inverse of <code>this</code>. <p> This method can be used to quickly obtain the inverse of a perspective projection matrix. <p> If this matrix represents a symmetric perspective frustum transformation, as obtained via {@link #perspective(double, double, double, double) perspective()}, then {@link #invertPerspective()} should be used instead.

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

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

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

If <code>this</code> is a perspective projection matrix obtained via one of the {@link #perspective(double, double, double, double) perspective()} methods or via {@link #setPerspective(double, double, double, double) setPerspective()}, that is, if <code>this</code> is a symmetrical perspective frustum transformation, then this method builds the inverse of <code>this</code>. <p> This method can be used to quickly obtain the inverse of a perspective projection matrix when being obtained via {@link #perspective(double, double, double, double) perspective()}.

invertPerspectiveView
Matrix4d invertPerspectiveView(Matrix4d view, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
invertPerspectiveView
Matrix4d invertPerspectiveView(Matrix4x3d view, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
isAffine
bool isAffine()
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
Matrix4d lerp(Matrix4d 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
Matrix4d lerp(Matrix4d other, double t, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
lookAlong
Matrix4d 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(ref 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(ref Vector3d, Vector3d) setLookAlong()}.

lookAlong
Matrix4d lookAlong(Vector3d dir, Vector3d up, Matrix4d 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(ref 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(ref Vector3d, Vector3d) setLookAlong()}.

lookAlong
Matrix4d lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4d 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
Matrix4d 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
Matrix4d lookAt(Vector3d eye, Vector3d center, Vector3d up, Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.

lookAt
Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.

lookAt
Matrix4d lookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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
Matrix4d 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
Matrix4d lookAtLH(Vector3d eye, Vector3d center, Vector3d up, Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.

lookAtLH
Matrix4d 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(ref Vector3d, Vector3d, Vector3d)}.

lookAtLH
Matrix4d lookAtLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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
Matrix4d 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()}.

lookAtPerspective
Matrix4d lookAtPerspective(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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> This method assumes <code>this</code> to be a perspective transformation, obtained via {@link #frustum(double, double, double, double, double, double) frustum()} or {@link #perspective(double, double, double, double) perspective()} or one of their overloads. <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()}.

lookAtPerspectiveLH
Matrix4d lookAtPerspectiveLH(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ, Matrix4d 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> This method assumes <code>this</code> to be a perspective transformation, obtained via {@link #frustumLH(double, double, double, double, double, double) frustumLH()} or {@link #perspectiveLH(double, double, double, double) perspectiveLH()} or one of their overloads. <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()}.

mapXZY
Matrix4d mapXZY()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mapnXZY
Matrix4d mapnXZY()

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

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

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

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

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

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

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

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

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

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

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

mapnYXZ
Matrix4d mapnYXZ()

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

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

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

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

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

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

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

mapnYnXZ
Matrix4d mapnYnXZ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mapnZnYnX
Matrix4d mapnZnYnX(Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul
Matrix4d mul(Matrix3x2d right, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul
Matrix4d mul(Matrix3x2d right)

Multiply this matrix by the supplied <code>right</code> matrix and store the result in <code>this</code>. <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
Matrix4d mul(Matrix4x3d right, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul
Matrix4d mul(Matrix4x3d right)

Multiply this matrix by the supplied <code>right</code> matrix. <p> The last row of the <code>right</code> matrix is assumed to be <code>(0, 0, 0, 1)</code>. <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
Matrix4d mul(double r00, double r01, double r02, double r03, double r10, double r11, double r12, double r13, double r20, double r21, double r22, double r23, double r30, double r31, double r32, double r33, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul
Matrix4d mul(double r00, double r01, double r02, double r03, double r10, double r11, double r12, double r13, double r20, double r21, double r22, double r23, double r30, double r31, double r32, double r33)

Multiply this matrix by the matrix with the supplied elements. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix whose elements are supplied via the parameters, 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
Matrix4d mul(Matrix4d right, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul
Matrix4d mul(Matrix4d 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!

mul0
Matrix4d mul0(Matrix4d right, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul0
Matrix4d mul0(Matrix4d 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! <p> This method neither assumes nor checks for any matrix properties of <code>this</code> or <code>right</code> and will always perform a complete 4x4 matrix multiplication. This method should only be used whenever the multiplied matrices do not have any properties for which there are optimized multiplication methods available.

mul3x3
Matrix4d mul3x3(double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mul3x3
Matrix4d mul3x3(double r00, double r01, double r02, double r10, double r11, double r12, double r20, double r21, double r22)

Multiply this matrix by the 3x3 matrix with the supplied elements expanded to a 4x4 matrix with all other matrix elements set to identity. <p> If <code>M</code> is <code>this</code> matrix and <code>R</code> the <code>right</code> matrix whose elements are supplied via the parameters, 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!

mul4x3ComponentWise
Matrix4d mul4x3ComponentWise(Matrix4d other)

Component-wise multiply the upper 4x3 submatrices of <code>this</code> by <code>other</code>.

mul4x3ComponentWise
Matrix4d mul4x3ComponentWise(Matrix4d other, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulAffine
Matrix4d mulAffine(Matrix4d right, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulAffine
Matrix4d mulAffine(Matrix4d right)

Multiply this matrix by the supplied <code>right</code> matrix, both of which are assumed to be {@link #isAffine() affine}, and store the result in <code>this</code>. <p> This method assumes that <code>this</code> matrix and the given <code>right</code> matrix both represent an {@link #isAffine() affine} transformation (i.e. their last rows are equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrices only represent affine transformations, such as translation, rotation, scaling and shearing (in any combination). <p> This method will not modify either the last row of <code>this</code> or the last row of <code>right</code>. <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!

mulAffineR
Matrix4d mulAffineR(Matrix4d right, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulAffineR
Matrix4d mulAffineR(Matrix4d right)

Multiply this matrix by the supplied <code>right</code> matrix, which is assumed to be {@link #isAffine() affine}, and store the result in <code>this</code>. <p> This method assumes that the given <code>right</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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!

mulComponentWise
Matrix4d mulComponentWise(Matrix4d other, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulComponentWise
Matrix4d mulComponentWise(Matrix4d other)

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

mulLocal
Matrix4d mulLocal(Matrix4d left, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulLocal
Matrix4d mulLocal(Matrix4d left)

Pre-multiply this matrix by the supplied <code>left</code> matrix and store the result in <code>this</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the <code>left</code> matrix, then the new matrix will be <code>L * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>L * M * v</code>, the transformation of <code>this</code> matrix will be applied first!

mulLocalAffine
Matrix4d mulLocalAffine(Matrix4d left, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulLocalAffine
Matrix4d mulLocalAffine(Matrix4d left)

Pre-multiply this matrix by the supplied <code>left</code> matrix, both of which are assumed to be {@link #isAffine() affine}, and store the result in <code>this</code>. <p> This method assumes that <code>this</code> matrix and the given <code>left</code> matrix both represent an {@link #isAffine() affine} transformation (i.e. their last rows are equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrices only represent affine transformations, such as translation, rotation, scaling and shearing (in any combination). <p> This method will not modify either the last row of <code>this</code> or the last row of <code>left</code>. <p> If <code>M</code> is <code>this</code> matrix and <code>L</code> the <code>left</code> matrix, then the new matrix will be <code>L * M</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>L * M * v</code>, the transformation of <code>this</code> matrix will be applied first!

mulOrthoAffine
Matrix4d mulOrthoAffine(Matrix4d view, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulOrthoAffine
Matrix4d mulOrthoAffine(Matrix4d view)

Multiply <code>this</code> orthographic projection matrix by the supplied {@link #isAffine() affine} <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!

mulPerspectiveAffine
Matrix4d mulPerspectiveAffine(Matrix4d view, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
mulPerspectiveAffine
Matrix4d mulPerspectiveAffine(Matrix4d view)

Multiply <code>this</code> symmetric perspective projection matrix by the supplied {@link #isAffine() affine} <code>view</code> matrix. <p> If <code>P</code> is <code>this</code> matrix and <code>V</code> the <code>view</code> matrix, then the new matrix will be <code>P * V</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>P * V * v</code>, the transformation of the <code>view</code> matrix will be applied first!

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

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

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

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

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

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

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

Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code> and store it into <code>dest</code>. <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 Matrix3d#set(Matrix4d)} to set a given Matrix3d to only the upper left 3x3 submatrix of this matrix.

normal
Matrix4d normal(Matrix4d dest)

Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code> and store it into the upper 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(Matrix4d)} to set a given Matrix4d to only the upper left 3x3 submatrix of a given matrix.

normal
Matrix4d normal()

Compute a normal matrix from the upper left 3x3 submatrix of <code>this</code> and store it into the upper 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(Matrix4d)} to set a given Matrix4f to only the upper 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
Matrix4d normalize3x3(Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
normalize3x3
Matrix4d normalize3x3()

Normalize the upper 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
Matrix4d obliqueZ(double a, double b, Matrix4d 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 0 0 0 1 </pre>

obliqueZ
Matrix4d 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 0 0 0 1 </pre>

origin
Vector3d origin(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
originAffine
Vector3d originAffine(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
ortho
Matrix4d 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
Matrix4d 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
Matrix4d ortho(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d 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
Matrix4d ortho(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d 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
Matrix4d 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
Matrix4d ortho2D(double left, double right, double bottom, double top, Matrix4d 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, Matrix4d) 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
Matrix4d 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>

ortho2DLH
Matrix4d ortho2DLH(double left, double right, double bottom, double top, Matrix4d 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, Matrix4d) 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>

orthoCrop
Matrix4d orthoCrop(Matrix4d view, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
orthoLH
Matrix4d 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
Matrix4d 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
Matrix4d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, Matrix4d 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
Matrix4d orthoLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne, Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d orthoSymmetric(double width, double height, double zNear, double zFar, Matrix4d 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, Matrix4d) 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
Matrix4d orthoSymmetric(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d 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, Matrix4d) 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
Matrix4d 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>

orthoSymmetricLH
Matrix4d 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
Matrix4d orthoSymmetricLH(double width, double height, double zNear, double zFar, Matrix4d 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, Matrix4d) 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
Matrix4d orthoSymmetricLH(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d 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, Matrix4d) 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>

perspective
Matrix4d perspective(double fovy, double aspect, double zNear, double zFar)

Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double) setPerspective}.

perspective
Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne)

Apply a symmetric perspective projection frustum transformation using 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double, bool) setPerspective}.

perspective
Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, Matrix4d dest)

Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double) setPerspective}.

perspective
Matrix4d perspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)

Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspective(double, double, double, double, bool) setPerspective}.

perspectiveFar
double perspectiveFar()
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveFov
double perspectiveFov()
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveFrustumSlice
Matrix4d perspectiveFrustumSlice(double near, double far, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveInvOrigin
Vector3d perspectiveInvOrigin(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveLH
Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar)

Apply a symmetric perspective projection frustum transformation for a left-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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double) setPerspectiveLH}.

perspectiveLH
Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, Matrix4d dest)

Apply a symmetric perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double) setPerspectiveLH}.

perspectiveLH
Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne)

Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double, bool) setPerspectiveLH}.

perspectiveLH
Matrix4d perspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)

Apply a symmetric perspective projection frustum 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> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveLH(double, double, double, double, bool) setPerspectiveLH}.

perspectiveNear
double perspectiveNear()
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenter
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar)

Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double) setPerspectiveOffCenter}.

perspectiveOffCenter
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne)

Apply an asymmetric off-center perspective projection frustum transformation using for a right-handed coordinate system using the given NDC z range to this matrix. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double, bool) setPerspectiveOffCenter}.

perspectiveOffCenter
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, Matrix4d dest)

Apply an asymmetric off-center perspective projection frustum 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> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double) setPerspectiveOffCenter}.

perspectiveOffCenter
Matrix4d perspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)

Apply an asymmetric off-center perspective projection frustum 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> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenter(double, double, double, double, double, double, bool) setPerspectiveOffCenter}.

perspectiveOffCenterFov
Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFov
Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar)

Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFov(double, double, double, double, double, double) setPerspectiveOffCenterFov}.

perspectiveOffCenterFov
Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFov
Matrix4d perspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne)

Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFov(double, double, double, double, double, double, bool) setPerspectiveOffCenterFov}.

perspectiveOffCenterFovLH
Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFovLH
Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar)

Apply an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code> to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFovLH(double, double, double, double, double, double) setPerspectiveOffCenterFovLH}.

perspectiveOffCenterFovLH
Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveOffCenterFovLH
Matrix4d perspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne)

Apply an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range to this matrix. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> If <code>M</code> is <code>this</code> matrix and <code>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveOffCenterFovLH(double, double, double, double, double, double, bool) setPerspectiveOffCenterFovLH}.

perspectiveOrigin
Vector3d perspectiveOrigin(Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
perspectiveRect
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar)

Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double) setPerspectiveRect}.

perspectiveRect
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne)

Apply a symmetric perspective projection frustum transformation using 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double, bool) setPerspectiveRect}.

perspectiveRect
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, Matrix4d dest)

Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double) setPerspectiveRect}.

perspectiveRect
Matrix4d perspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne, Matrix4d dest)

Apply a symmetric perspective projection frustum 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>P</code> the perspective projection matrix, then the new matrix will be <code>M * P</code>. So when transforming a vector <code>v</code> with the new matrix by using <code>M * P * v</code>, the perspective projection will be applied first! <p> In order to set the matrix to a perspective frustum transformation without post-multiplying, use {@link #setPerspectiveRect(double, double, double, double, bool) setPerspectiveRect}.

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

pick
Matrix4d pick(double x, double y, double width, double height, int[] viewport, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
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.
project
Vector4d project(Vector3d position, int[] viewport, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
project
Vector3d project(double x, double y, double z, int[] viewport, Vector3d winCoordsDest)
Undocumented in source. Be warned that the author may not have intended to support it.
project
Vector3d project(Vector3d position, int[] viewport, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
project
Vector4d project(double x, double y, double z, int[] viewport, Vector4d winCoordsDest)
Undocumented in source. Be warned that the author may not have intended to support it.
projectedGridRange
Matrix4d projectedGridRange(Matrix4d projector, double sLower, double sUpper, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4d reflect(Vector3d normal, Vector3d point, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4d reflect(Quaterniond orientation, Vector3d point, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4d 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
Matrix4d 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
Matrix4d reflect(double nx, double ny, double nz, double px, double py, double pz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflect
Matrix4d 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
Matrix4d 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
Matrix4d reflect(double a, double b, double c, double d, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
reflection
Matrix4d 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>.

reflection
Matrix4d 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
Matrix4d 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
Matrix4d 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>

rotate
Matrix4d rotate(double ang, double x, double y, double z, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotate
Matrix4d 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
Matrix4d 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
Matrix4d rotate(Quaterniond quat, Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotate
Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotate
Matrix4d rotate(double angle, Vector3d axis, Matrix4d 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>

rotate
Matrix4d rotate(AxisAngle4d axisAngle, Matrix4d 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(ref AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotate
Matrix4d 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(ref AxisAngle4d)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotateAffine
Matrix4d rotateAffine(Quaterniond quat, Matrix4d dest)

Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this {@link #isAffine() affine} matrix and store the result in <code>dest</code>. <p> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateAffine
Matrix4d rotateAffine(Quaterniond quat)

Apply the rotation - and possibly scaling - transformation of the given {@link Quaterniond} to this matrix. <p> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateAffine
Matrix4d rotateAffine(double ang, double x, double y, double z, Matrix4d dest)

Apply rotation to this {@link #isAffine() affine} 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> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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>

rotateAffine
Matrix4d rotateAffine(double ang, double x, double y, double z)

Apply rotation to this {@link #isAffine() affine} matrix by rotating the given amount of radians about the specified <code>(x, y, z)</code> axis. <p> This method assumes <code>this</code> to be {@link #isAffine() affine}. <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>

rotateAffineXYZ
Matrix4d rotateAffineXYZ(double angleX, double angleY, double angleZ, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateAffineXYZ
Matrix4d rotateAffineXYZ(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> This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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>

rotateAffineYXZ
Matrix4d rotateAffineYXZ(double angleY, double angleX, double angleZ, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateAffineYXZ
Matrix4d rotateAffineYXZ(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> This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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!

rotateAffineZYX
Matrix4d rotateAffineZYX(double angleZ, double angleY, double angleX, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateAffineZYX
Matrix4d rotateAffineZYX(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> This method assumes that <code>this</code> matrix represents an {@link #isAffine() affine} transformation (i.e. its last row is equal to <code>(0, 0, 0, 1)</code>) and can be used to speed up matrix multiplication if the matrix only represents affine transformations, such as translation, rotation, scaling and shearing (in any combination). <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!

rotateAround
Matrix4d 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>

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

Pre-multiply the rotation - and possibly scaling - 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>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> This method is equivalent to calling: <code>translateLocal(-ox, -oy, -oz).rotateLocal(quat).translateLocal(ox, oy, oz)</code> <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateAroundLocal
Matrix4d rotateAroundLocal(Quaterniond quat, double ox, double oy, double oz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateLocal
Matrix4d rotateLocal(Quaterniond quat, Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateLocal
Matrix4d rotateLocal(Quaterniond quat)

Pre-multiply 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>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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateLocal
Matrix4d 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
Matrix4d rotateLocal(double ang, double x, double y, double z, Matrix4d 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
Matrix4d 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
Matrix4d rotateLocalX(double ang, Matrix4d 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
Matrix4d 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
Matrix4d rotateLocalY(double ang, Matrix4d 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
Matrix4d 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
Matrix4d rotateLocalZ(double ang, Matrix4d 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
Matrix4d rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix4d 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(double, double, double, double, double, double) rotationTowards()}. <p> This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine(), dest)</code>

rotateTowards
Matrix4d 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>mulAffine(new Matrix4d().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine())</code>

rotateTowards
Matrix4d rotateTowards(Vector3d direction, 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>direction</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(ref Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invertAffine())</code>

rotateTowards
Matrix4d rotateTowards(Vector3d direction, Vector3d up, Matrix4d dest)

Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local <code>+Z</code> axis with <code>direction</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(ref Vector3d, Vector3d) rotationTowards()}. <p> This method is equivalent to calling: <code>mulAffine(new Matrix4d().lookAt(new Vector3d(), new Vector3d(dir).negate(), up).invertAffine(), dest)</code>

rotateTowardsXY
Matrix4d rotateTowardsXY(double dirX, double dirY, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateTowardsXY
Matrix4d rotateTowardsXY(double dirX, double dirY)

Apply rotation about the Z axis to align the local <code>+X</code> towards <code>(dirX, dirY)</code>. <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> The vector <code>(dirX, dirY)</code> must be a unit vector.

rotateTranslation
Matrix4d rotateTranslation(Quaterniond quat, Matrix4d 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(ref Quaterniond)}. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotateTranslation
Matrix4d rotateTranslation(double ang, double x, double y, double z, Matrix4d 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
Matrix4d 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
Matrix4d rotateX(double ang, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ
Matrix4d rotateXYZ(double angleX, double angleY, double angleZ, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateXYZ
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d rotateY(double ang, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ
Matrix4d rotateYXZ(double angleY, double angleX, double angleZ, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateYXZ
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d rotateZ(double ang, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX
Matrix4d rotateZYX(double angleZ, double angleY, double angleX, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
rotateZYX
Matrix4d 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
Matrix4d 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
Matrix4d 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>

rotation
Matrix4d 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
Matrix4d 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(ref Quaterniond) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Quaternion">http://en.wikipedia.org</a>

rotation
Matrix4d 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(ref AxisAngle4d) rotate()} instead. <p> Reference: <a href="http://en.wikipedia.org/wiki/Rotation_matrix#Axis_and_angle">http://en.wikipedia.org</a>

rotationAround
Matrix4d 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
Matrix4d 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>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(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine()</code>

rotationTowards
Matrix4d 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).invertAffine()</code>

rotationTowardsXY
Matrix4d rotationTowardsXY(double dirX, double dirY)

Set this matrix to a rotation transformation about the Z axis to align the local <code>+X</code> towards <code>(dirX, dirY)</code>. <p> The vector <code>(dirX, dirY)</code> must be a unit vector.

rotationX
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d scale(Vector3d xyz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scale
Matrix4d 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
Matrix4d scale(double x, double y, double z, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scale
Matrix4d 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
Matrix4d scale(double xyz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scale
Matrix4d 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!

scaleAround
Matrix4d scaleAround(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleAround
Matrix4d 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
Matrix4d 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
Matrix4d scaleAround(double factor, double ox, double oy, double oz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleAroundLocal
Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleAroundLocal
Matrix4d scaleAroundLocal(double sx, double sy, double sz, double ox, double oy, double oz)

Pre-multiply 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>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! <p> This method is equivalent to calling: <code>new Matrix4d().translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz).mul(this, this)</code>

scaleAroundLocal
Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz)

Pre-multiply 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>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! <p> This method is equivalent to calling: <code>new Matrix4d().translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz).mul(this, this)</code>

scaleAroundLocal
Matrix4d scaleAroundLocal(double factor, double ox, double oy, double oz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal
Matrix4d scaleLocal(double x, double y, double z, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal
Matrix4d scaleLocal(double xyz, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleLocal
Matrix4d scaleLocal(double xyz)

Pre-multiply scaling to this matrix by scaling the 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>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
Matrix4d 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!

scaleXY
Matrix4d scaleXY(double x, double y, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
scaleXY
Matrix4d 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!

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

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

Set this matrix to be a simple scale matrix.

scaling
Matrix4d 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(ref Vector3d) scale()} instead.

set
Matrix4d set(Matrix3d mat)

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

set
Matrix4d set(AxisAngle4d axisAngle)

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

set
Matrix4d 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> <p> Reference: <a href="http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/">http://www.euclideanspace.com/</a>

set
Matrix4d set(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33)

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

set
Matrix4d 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
Matrix4d 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
Matrix4d set(Vector4d col0, Vector4d col1, Vector4d col2, Vector4d col3)

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

set
Matrix4d set(Matrix4d m)

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

set
Matrix4d set(Matrix4x3d m)

Store the values of the given matrix <code>m</code> into <code>this</code> matrix and set the other matrix elements to identity.

set
Matrix4d set(int column, int row, double value)

Set the matrix element at the given column and row to the specified value.

set3x3
Matrix4d set3x3(Matrix4d mat)

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

set3x3
Matrix4d set3x3(Matrix3d mat)

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

set4x3
Matrix4d set4x3(Matrix4x3d mat)

Set the upper 4x3 submatrix of this {@link Matrix4d} to the given {@link Matrix4x3d} and don't change the other elements.

set4x3
Matrix4d set4x3(Matrix4d mat)

Set the upper 4x3 submatrix of this {@link Matrix4d} to the upper 4x3 submatrix of the given {@link Matrix4d} and don't change the other elements.

setColumn
Matrix4d setColumn(int column, Vector4d src)

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

setFromIntrinsic
Matrix4d setFromIntrinsic(double alphaX, double alphaY, double gamma, double u0, double v0, int imgWidth, int imgHeight, double near, double far)

Set this matrix to represent a perspective projection equivalent to the given intrinsic camera calibration parameters. The resulting matrix will be suited for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> See: <a href="https://en.wikipedia.org/wiki/Camera_resectioning#Intrinsic_parameters">https://en.wikipedia.org/</a> <p> Reference: <a href="http://ksimek.github.io/2013/06/03/calibrated_cameras_in_opengl/">http://ksimek.github.io/</a>

setFrustum
Matrix4d setFrustum(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

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

setFrustum
Matrix4d setFrustum(double left, double right, double bottom, double top, double zNear, double zFar)

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

setFrustumLH
Matrix4d setFrustumLH(double left, double right, double bottom, double top, double zNear, double zFar, bool zZeroToOne)

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

setFrustumLH
Matrix4d setFrustumLH(double left, double right, double bottom, double top, double zNear, double zFar)

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

setLookAlong
Matrix4d 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(ref 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(ref Vector3d, Vector3d)}.

setLookAlong
Matrix4d 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()}

setLookAt
Matrix4d 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(ref Vector3d, Vector3d, Vector3d) lookAt()}.

setLookAt
Matrix4d 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}.

setLookAtLH
Matrix4d 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(ref Vector3d, Vector3d, Vector3d) lookAt()}.

setLookAtLH
Matrix4d 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}.

setOrtho
Matrix4d 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>

setOrtho
Matrix4d 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>

setOrtho2D
Matrix4d 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
Matrix4d 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
Matrix4d 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>

setOrthoLH
Matrix4d 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>

setOrthoSymmetric
Matrix4d 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>

setOrthoSymmetric
Matrix4d 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>

setOrthoSymmetricLH
Matrix4d 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>

setOrthoSymmetricLH
Matrix4d 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>

setPerspective
Matrix4d setPerspective(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspective(double, double, double, double, bool) perspective()}.

setPerspective
Matrix4d setPerspective(double fovy, double aspect, double zNear, double zFar)

Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspective(double, double, double, double) perspective()}.

setPerspectiveLH
Matrix4d setPerspectiveLH(double fovy, double aspect, double zNear, double zFar)

Set this matrix to be a symmetric perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveLH(double, double, double, double) perspectiveLH()}.

setPerspectiveLH
Matrix4d setPerspectiveLH(double fovy, double aspect, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be a symmetric perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveLH(double, double, double, double, bool) perspectiveLH()}.

setPerspectiveOffCenter
Matrix4d setPerspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenter(double, double, double, double, double, double) perspectiveOffCenter()}.

setPerspectiveOffCenter
Matrix4d setPerspectiveOffCenter(double fovy, double offAngleX, double offAngleY, double aspect, double zNear, double zFar)

Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> The given angles <code>offAngleX</code> and <code>offAngleY</code> are the horizontal and vertical angles between the line of sight and the line given by the center of the near and far frustum planes. So, when <code>offAngleY</code> is just <code>fovy/2</code> then the projection frustum is rotated towards +Y and the bottom frustum plane is parallel to the XZ-plane. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenter(double, double, double, double, double, double) perspectiveOffCenter()}.

setPerspectiveOffCenterFov
Matrix4d setPerspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFov(double, double, double, double, double, double, bool) perspectiveOffCenterFov()}.

setPerspectiveOffCenterFov
Matrix4d setPerspectiveOffCenterFov(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar)

Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFov(double, double, double, double, double, double) perspectiveOffCenterFov()}.

setPerspectiveOffCenterFovLH
Matrix4d setPerspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using the given NDC z range. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFovLH(double, double, double, double, double, double, bool) perspectiveOffCenterFovLH()}.

setPerspectiveOffCenterFovLH
Matrix4d setPerspectiveOffCenterFovLH(double angleLeft, double angleRight, double angleDown, double angleUp, double zNear, double zFar)

Set this matrix to be an asymmetric off-center perspective projection frustum transformation for a left-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> The given angles <code>angleLeft</code> and <code>angleRight</code> are the horizontal angles between the left and right frustum planes, respectively, and a line perpendicular to the near and far frustum planes. The angles <code>angleDown</code> and <code>angleUp</code> are the vertical angles between the bottom and top frustum planes, respectively, and a line perpendicular to the near and far frustum planes. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveOffCenterFovLH(double, double, double, double, double, double) perspectiveOffCenterFovLH()}.

setPerspectiveRect
Matrix4d setPerspectiveRect(double width, double height, double zNear, double zFar)

Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using OpenGL's NDC z range of <code>[-1..+1]</code>. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveRect(double, double, double, double) perspectiveRect()}.

setPerspectiveRect
Matrix4d setPerspectiveRect(double width, double height, double zNear, double zFar, bool zZeroToOne)

Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system using the given NDC z range. <p> In order to apply the perspective projection transformation to an existing transformation, use {@link #perspectiveRect(double, double, double, double, bool) perspectiveRect()}.

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

Set only the upper 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
Matrix4d setRotationYXZ(double angleY, double angleX, double angleZ)

Set only the upper 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
Matrix4d setRotationZYX(double angleZ, double angleY, double angleX)

Set only the upper 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
Matrix4d setRow(int row, Vector4d src)

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

setRowColumn
Matrix4d setRowColumn(int row, int column, double value)

Set the matrix element at the given row and column to the specified value.

setTranslation
Matrix4d 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(ref Vector3d)}. To apply a translation, use {@link #translate(ref Vector3d)}.

setTranslation
Matrix4d 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)}.

setTransposed
Matrix4d setTransposed(Matrix4d m)

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

setm00
Matrix4d setm00(double m00)

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

setm01
Matrix4d setm01(double m01)

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

setm02
Matrix4d setm02(double m02)

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

setm03
Matrix4d setm03(double m03)

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

setm10
Matrix4d setm10(double m10)

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

setm11
Matrix4d setm11(double m11)

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

setm12
Matrix4d setm12(double m12)

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

setm13
Matrix4d setm13(double m13)

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

setm20
Matrix4d setm20(double m20)

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

setm21
Matrix4d setm21(double m21)

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

setm22
Matrix4d setm22(double m22)

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

setm23
Matrix4d setm23(double m23)

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

setm30
Matrix4d setm30(double m30)

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

setm31
Matrix4d setm31(double m31)

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

setm32
Matrix4d setm32(double m32)

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

setm33
Matrix4d setm33(double m33)

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

shadow
Matrix4d shadow(Vector4d light, double a, double b, double c, double d, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4d 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>

shadow
Matrix4d 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
Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, double a, double b, double c, double d, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4d shadow(Vector4d light, Matrix4d planeTransform, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4d shadow(Vector4d light, Matrix4d 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
Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4d planeTransform, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
shadow
Matrix4d shadow(double lightX, double lightY, double lightZ, double lightW, Matrix4d 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!

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

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

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

Component-wise subtract the upper 4x3 submatrices of <code>subtrahend</code> from <code>this</code>.

swap
Matrix4d swap(Matrix4d other)

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

testAab
bool testAab(double minX, double minY, double minZ, double maxX, double maxY, double maxZ)
Undocumented in source. Be warned that the author may not have intended to support it.
testPoint
bool testPoint(double x, double y, double z)
Undocumented in source. Be warned that the author may not have intended to support it.
testSphere
bool testSphere(double x, double y, double z, double r)
Undocumented in source. Be warned that the author may not have intended to support it.
tile
Matrix4d tile(int x, int y, int w, int h, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
tile
Matrix4d tile(int x, int y, int w, int h)

This method is equivalent to calling: <code>translate(w-1-2*x, h-1-2*y, 0).scale(w, h, 1)</code> <p> If <code>M</code> is <code>this</code> matrix and <code>T</code> the created transformation 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 created transformation will be applied first!

transform
Vector4d transform(double x, double y, double z, double w, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
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
Matrix4d 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
Matrix4d transformAab(Vector3d min, Vector3d max, Vector3d outMin, Vector3d outMax)
Undocumented in source. Be warned that the author may not have intended to support it.
transformAffine
Vector4d transformAffine(double x, double y, double z, double w, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformAffine
Vector4d transformAffine(Vector4d v, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformAffine
Vector4d transformAffine(Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformDirection
Vector3d transformDirection(double x, double y, double z, Vector3d dest)
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 dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformPosition
Vector3d transformPosition(double x, double y, double z, Vector3d dest)
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 dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector3d transformProject(double x, double y, double z, double w, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector3d transformProject(Vector4d v, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector3d transformProject(double x, double y, double z, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector3d transformProject(Vector3d v, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector3d transformProject(Vector3d v)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector4d transformProject(double x, double y, double z, double w, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector4d transformProject(Vector4d v, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformProject
Vector4d transformProject(Vector4d v)
Undocumented in source. Be warned that the author may not have intended to support it.
transformTranspose
Vector4d transformTranspose(double x, double y, double z, double w, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformTranspose
Vector4d transformTranspose(Vector4d v, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
transformTranspose
Vector4d transformTranspose(Vector4d v)
Undocumented in source. Be warned that the author may not have intended to support it.
translate
Matrix4d 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
Matrix4d translate(double x, double y, double z, Matrix4d 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
Matrix4d translate(Vector3d offset, Matrix4d 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(ref Vector3d)}.

translate
Matrix4d 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(ref Vector3d)}.

translateLocal
Matrix4d 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
Matrix4d translateLocal(double x, double y, double z, Matrix4d 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
Matrix4d translateLocal(Vector3d offset, Matrix4d 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(ref Vector3d)}.

translateLocal
Matrix4d 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(ref Vector3d)}.

translation
Matrix4d 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
Matrix4d 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
Matrix4d 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
Matrix4d 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 - and possibly scaling - transformation specified by the given quaternion. <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
Matrix4d 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>

translationRotateInvert
Matrix4d 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>

translationRotateScale
Matrix4d 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>

translationRotateScale
Matrix4d 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
Matrix4d translationRotateScale(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double scale)

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 all three 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(tx, ty, tz).rotate(quat).scale(scale)</code>

translationRotateScale
Matrix4d translationRotateScale(Vector3d translation, Quaterniond quat, double 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 all three 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>

translationRotateScaleInvert
Matrix4d translationRotateScaleInvert(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)<sup>-1</sup></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> This method is equivalent to calling: <code>translationRotateScale(...).invert()</code>

translationRotateScaleInvert
Matrix4d translationRotateScaleInvert(Vector3d translation, Quaterniond quat, Vector3d scale)

Set <code>this</code> matrix to <code>(T * R * S)<sup>-1</sup></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> This method is equivalent to calling: <code>translationRotateScale(...).invert()</code>

translationRotateScaleInvert
Matrix4d translationRotateScaleInvert(Vector3d translation, Quaterniond quat, double scale)

Set <code>this</code> matrix to <code>(T * R * S)<sup>-1</sup></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 all three axes by <code>scale</code>. <p> This method is equivalent to calling: <code>translationRotateScale(...).invert()</code>

translationRotateScaleMulAffine
Matrix4d translationRotateScaleMulAffine(double tx, double ty, double tz, double qx, double qy, double qz, double qw, double sx, double sy, double sz, Matrix4d 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 - and possibly scaling - 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> and <code>M</code> is an {@link #isAffine() affine} matrix. <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).mulAffine(m)</code>

translationRotateTowards
Matrix4d 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
Matrix4d 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>

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

Transpose this matrix.

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

Transpose only the upper left 3x3 submatrix of this matrix. <p> All other matrix elements are left unchanged.

trapezoidCrop
Matrix4d trapezoidCrop(double p0x, double p0y, double p1x, double p1y, double p2x, double p2y, double p3x, double p3y)

Set <code>this</code> matrix to a perspective transformation that maps the trapezoid spanned by the four corner coordinates <code>(p0x, p0y)</code>, <code>(p1x, p1y)</code>, <code>(p2x, p2y)</code> and <code>(p3x, p3y)</code> to the unit square <code>[(-1, -1)..(+1, +1)]</code>. <p> The corner coordinates are given in counter-clockwise order starting from the <i>left</i> corner on the smaller parallel side of the trapezoid seen when looking at the trapezoid oriented with its shorter parallel edge at the bottom and its longer parallel edge at the top. <p> Reference: <a href="http://www.comp.nus.edu.sg/~tants/tsm/TSM_recipe.html">Trapezoidal Shadow Maps (TSM) - Recipe</a>

unproject
Vector4d unproject(Vector3d winCoords, int[] viewport, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unproject
Vector3d unproject(double winX, double winY, double winZ, int[] viewport, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unproject
Vector4d unproject(double winX, double winY, double winZ, int[] viewport, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unproject
Vector3d unproject(Vector3d winCoords, int[] viewport, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv
Vector3d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv
Vector3d unprojectInv(Vector3d winCoords, int[] viewport, Vector3d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv
Vector4d unprojectInv(double winX, double winY, double winZ, int[] viewport, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInv
Vector4d unprojectInv(Vector3d winCoords, int[] viewport, Vector4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInvRay
Matrix4d unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectInvRay
Matrix4d unprojectInvRay(Vector2d winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectRay
Matrix4d unprojectRay(Vector2d winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest)
Undocumented in source. Be warned that the author may not have intended to support it.
unprojectRay
Matrix4d unprojectRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest)
Undocumented in source. Be warned that the author may not have intended to support it.
withLookAtUp
Matrix4d withLookAtUp(double upX, double upY, double upZ, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
withLookAtUp
Matrix4d withLookAtUp(double upX, double upY, double upZ)

Apply a transformation to this matrix to ensure that the local Y axis (as obtained by {@link #positiveY(ref Vector3d)}) will be coplanar to the plane spanned by the local Z axis (as obtained by {@link #positiveZ(ref Vector3d)}) and the given vector <code>(upX, upY, upZ)</code>. <p> This effectively ensures that the resulting matrix will be equal to the one obtained from {@link #setLookAt(double, double, double, double, double, double, double, double, double)} called with the current local origin of this matrix (as obtained by {@link #originAffine(ref Vector3d)}), the sum of this position and the negated local Z axis as well as the given vector <code>(upX, upY, upZ)</code>. <p> This method must only be called on {@link #isAffine()} matrices.

withLookAtUp
Matrix4d withLookAtUp(Vector3d up, Matrix4d dest)
Undocumented in source. Be warned that the author may not have intended to support it.
withLookAtUp
Matrix4d withLookAtUp(Vector3d up)

Apply a transformation to this matrix to ensure that the local Y axis (as obtained by {@link #positiveY(ref Vector3d)}) will be coplanar to the plane spanned by the local Z axis (as obtained by {@link #positiveZ(ref Vector3d)}) and the given vector <code>up</code>. <p> This effectively ensures that the resulting matrix will be equal to the one obtained from {@link #setLookAt(ref Vector3d, Vector3d, Vector3d)} called with the current local origin of this matrix (as obtained by {@link #originAffine(ref Vector3d)}), the sum of this position and the negated local Z axis as well as the given vector <code>up</code>. <p> This method must only be called on {@link #isAffine()} matrices.

zero
Matrix4d zero()

Set all the values within this matrix to 0.

Static functions

projViewFromRectangle
void projViewFromRectangle(Vector3d eye, Vector3d p, Vector3d x, Vector3d y, double nearFarDist, bool zeroToOne, Matrix4d projDest, Matrix4d viewDest)

Create a view and projection matrix from a given <code>eye</code> position, a given bottom left corner position <code>p</code> of the near plane rectangle and the extents of the near plane rectangle along its local <code>x</code> and <code>y</code> axes, and store the resulting matrices in <code>projDest</code> and <code>viewDest</code>. <p> This method creates a view and perspective projection matrix assuming that there is a pinhole camera at position <code>eye</code> projecting the scene onto the near plane defined by the rectangle. <p> All positions and lengths are in the same (world) unit.

Static variables

CORNER_NXNYNZ
int CORNER_NXNYNZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, -1, -1)</code> when using the identity matrix.

CORNER_NXNYPZ
int CORNER_NXNYPZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, -1, 1)</code> when using the identity matrix.

CORNER_NXPYNZ
int CORNER_NXPYNZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, 1, -1)</code> when using the identity matrix.

CORNER_NXPYPZ
int CORNER_NXPYPZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(-1, 1, 1)</code> when using the identity matrix.

CORNER_PXNYNZ
int CORNER_PXNYNZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, -1, -1)</code> when using the identity matrix.

CORNER_PXNYPZ
int CORNER_PXNYPZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, -1, 1)</code> when using the identity matrix.

CORNER_PXPYNZ
int CORNER_PXPYNZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, 1, -1)</code> when using the identity matrix.

CORNER_PXPYPZ
int CORNER_PXPYPZ;

Argument to the first parameter of {@link #frustumCorner(int, Vector3d)} identifying the corner <code>(1, 1, 1)</code> when using the identity matrix.

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_AFFINE
byte PROPERTY_AFFINE;

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

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 upper-left 3x3 submatrix represents an orthogonal matrix (i.e. orthonormal basis). For practical reasons, this property also always implies {@link #PROPERTY_AFFINE} in this implementation.

PROPERTY_PERSPECTIVE
byte PROPERTY_PERSPECTIVE;

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

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.
m03
double m03;
Undocumented in source.
m10
double m10;
Undocumented in source.
m11
double m11;
Undocumented in source.
m12
double m12;
Undocumented in source.
m13
double m13;
Undocumented in source.
m20
double m20;
Undocumented in source.
m21
double m21;
Undocumented in source.
m22
double m22;
Undocumented in source.
m23
double m23;
Undocumented in source.
m30
double m30;
Undocumented in source.
m31
double m31;
Undocumented in source.
m32
double m32;
Undocumented in source.
m33
double m33;
Undocumented in source.
properties
int properties;
Undocumented in source.

Meta