public class Matrix4f extends Object implements Externalizable, Matrix4fc
m00 m10 m20 m30
m01 m11 m21 m31
m02 m12 m22 m32
m03 m13 m23 m33
CORNER_NXNYNZ, CORNER_NXNYPZ, CORNER_NXPYNZ, CORNER_NXPYPZ, CORNER_PXNYNZ, CORNER_PXNYPZ, CORNER_PXPYNZ, CORNER_PXPYPZ, PLANE_NX, PLANE_NY, PLANE_NZ, PLANE_PX, PLANE_PY, PLANE_PZ, PROPERTY_AFFINE, PROPERTY_IDENTITY, PROPERTY_ORTHONORMAL, PROPERTY_PERSPECTIVE, PROPERTY_TRANSLATION| Constructor and Description |
|---|
Matrix4f()
|
Matrix4f(FloatBuffer buffer)
Create a new
Matrix4f by reading its 16 float components from the given FloatBuffer
at the buffer's current position. |
Matrix4f(float m00,
float m01,
float m02,
float m03,
float m10,
float m11,
float m12,
float m13,
float m20,
float m21,
float m22,
float m23,
float m30,
float m31,
float m32,
float m33)
Create a new 4x4 matrix using the supplied float values.
|
Matrix4f(Matrix3fc mat)
|
Matrix4f(Matrix4dc mat)
Create a new
Matrix4f and make it a copy of the given matrix. |
Matrix4f(Matrix4fc mat)
Create a new
Matrix4f and make it a copy of the given matrix. |
Matrix4f(Matrix4x3fc mat)
Create a new
Matrix4f and set its upper 4x3 submatrix to the given matrix mat
and all other elements to identity. |
Matrix4f(Vector4fc col0,
Vector4fc col1,
Vector4fc col2,
Vector4fc col3)
Create a new
Matrix4f and initialize its four columns using the supplied vectors. |
| Modifier and Type | Method and Description |
|---|---|
Matrix4f |
_m00(float m00)
Set the value of the matrix element at column 0 and row 0 without updating the properties of the matrix.
|
Matrix4f |
_m01(float m01)
Set the value of the matrix element at column 0 and row 1 without updating the properties of the matrix.
|
Matrix4f |
_m02(float m02)
Set the value of the matrix element at column 0 and row 2 without updating the properties of the matrix.
|
Matrix4f |
_m03(float m03)
Set the value of the matrix element at column 0 and row 3 without updating the properties of the matrix.
|
Matrix4f |
_m10(float m10)
Set the value of the matrix element at column 1 and row 0 without updating the properties of the matrix.
|
Matrix4f |
_m11(float m11)
Set the value of the matrix element at column 1 and row 1 without updating the properties of the matrix.
|
Matrix4f |
_m12(float m12)
Set the value of the matrix element at column 1 and row 2 without updating the properties of the matrix.
|
Matrix4f |
_m13(float m13)
Set the value of the matrix element at column 1 and row 3 without updating the properties of the matrix.
|
Matrix4f |
_m20(float m20)
Set the value of the matrix element at column 2 and row 0 without updating the properties of the matrix.
|
Matrix4f |
_m21(float m21)
Set the value of the matrix element at column 2 and row 1 without updating the properties of the matrix.
|
Matrix4f |
_m22(float m22)
Set the value of the matrix element at column 2 and row 2 without updating the properties of the matrix.
|
Matrix4f |
_m23(float m23)
Set the value of the matrix element at column 2 and row 3 without updating the properties of the matrix.
|
Matrix4f |
_m30(float m30)
Set the value of the matrix element at column 3 and row 0 without updating the properties of the matrix.
|
Matrix4f |
_m31(float m31)
Set the value of the matrix element at column 3 and row 1 without updating the properties of the matrix.
|
Matrix4f |
_m32(float m32)
Set the value of the matrix element at column 3 and row 2 without updating the properties of the matrix.
|
Matrix4f |
_m33(float m33)
Set the value of the matrix element at column 3 and row 3 without updating the properties of the matrix.
|
Matrix4f |
add(Matrix4fc other)
Component-wise add
this and other. |
Matrix4f |
add(Matrix4fc other,
Matrix4f dest)
Component-wise add
this and other and store the result in dest. |
Matrix4f |
add4x3(Matrix4fc other)
Component-wise add the upper 4x3 submatrices of
this and other. |
Matrix4f |
add4x3(Matrix4fc other,
Matrix4f dest)
Component-wise add the upper 4x3 submatrices of
this and other
and store the result in dest. |
Matrix4f |
affineSpan(Vector3f corner,
Vector3f xDir,
Vector3f yDir,
Vector3f zDir)
Compute the extents of the coordinate system before this
affine transformation was applied
and store the resulting corner coordinates in corner and the span vectors in
xDir, yDir and zDir. |
Matrix4f |
arcball(float radius,
float centerX,
float centerY,
float centerZ,
float angleX,
float angleY)
Apply an arcball view transformation to this matrix with the given
radius and center (centerX, centerY, centerZ)
position of the arcball and the specified X and Y rotation angles. |
Matrix4f |
arcball(float radius,
float centerX,
float centerY,
float centerZ,
float angleX,
float angleY,
Matrix4f dest)
Apply an arcball view transformation to this matrix with the given
radius and center (centerX, centerY, centerZ)
position of the arcball and the specified X and Y rotation angles, and store the result in dest. |
Matrix4f |
arcball(float radius,
Vector3fc center,
float angleX,
float angleY)
Apply an arcball view transformation to this matrix with the given
radius and center
position of the arcball and the specified X and Y rotation angles. |
Matrix4f |
arcball(float radius,
Vector3fc center,
float angleX,
float angleY,
Matrix4f dest)
Apply an arcball view transformation to this matrix with the given
radius and center
position of the arcball and the specified X and Y rotation angles, and store the result in dest. |
Matrix4f |
assume(int properties)
Assume the given properties about this matrix.
|
Matrix4f |
billboardCylindrical(Vector3fc objPos,
Vector3fc targetPos,
Vector3fc up)
Set this matrix to a cylindrical billboard transformation that rotates the local +Z axis of a given object with position
objPos towards
a target position at targetPos while constraining a cylindrical rotation around the given up vector. |
Matrix4f |
billboardSpherical(Vector3fc objPos,
Vector3fc targetPos)
Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position
objPos towards
a target position at targetPos using a shortest arc rotation by not preserving any up vector of the object. |
Matrix4f |
billboardSpherical(Vector3fc objPos,
Vector3fc targetPos,
Vector3fc up)
Set this matrix to a spherical billboard transformation that rotates the local +Z axis of a given object with position
objPos towards
a target position at targetPos. |
float |
determinant()
Return the determinant of this matrix.
|
float |
determinant3x3()
Return the determinant of the upper left 3x3 submatrix of this matrix.
|
float |
determinantAffine()
Return the determinant of this matrix by assuming that it represents an
affine transformation and thus
its last row is equal to (0, 0, 0, 1). |
Matrix4f |
determineProperties()
Compute and set the matrix properties returned by
properties() based
on the current matrix element values. |
boolean |
equals(Matrix4fc m,
float delta)
Compare the matrix elements of
this matrix with the given matrix using the given delta
and return whether all of them are equal within a maximum difference of delta. |
boolean |
equals(Object obj) |
Matrix4f |
fma4x3(Matrix4fc other,
float otherFactor)
Component-wise add the upper 4x3 submatrices of
this and other
by first multiplying each component of other's 4x3 submatrix by otherFactor and
adding that result to this. |
Matrix4f |
fma4x3(Matrix4fc other,
float otherFactor,
Matrix4f dest)
Component-wise add the upper 4x3 submatrices of
this and other
by first multiplying each component of other's 4x3 submatrix by otherFactor,
adding that to this and storing the final result in dest. |
Matrix4f |
frustum(float left,
float right,
float bottom,
float top,
float zNear,
float zFar)
Apply an arbitrary perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
frustum(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Apply an arbitrary perspective projection frustum transformation for a right-handed coordinate system
using the given NDC z range to this matrix.
|
Matrix4f |
frustum(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
frustum(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
Matrix4f dest)
Apply an arbitrary perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Matrix4f |
frustumAabb(Vector3f min,
Vector3f max)
Compute the axis-aligned bounding box of the frustum described by
this matrix and store the minimum corner
coordinates in the given min and the maximum corner coordinates in the given max vector. |
Vector3f |
frustumCorner(int corner,
Vector3f point)
Compute the corner coordinates of the frustum defined by
this matrix, which
can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given point. |
Matrix4f |
frustumLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar)
Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system
using the given NDC z range to this matrix.
|
Matrix4f |
frustumLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system
using the given NDC z range to this matrix.
|
Matrix4f |
frustumLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
frustumLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
Matrix4f dest)
Apply an arbitrary perspective projection frustum transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Planef |
frustumPlane(int which,
Planef plane)
Calculate a frustum plane of
this matrix, which
can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given plane. |
Vector4f |
frustumPlane(int plane,
Vector4f planeEquation)
Calculate a frustum plane of
this matrix, which
can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given planeEquation. |
Vector3f |
frustumRayDir(float x,
float y,
Vector3f dir)
Obtain the direction of a ray starting at the center of the coordinate system and going
through the near frustum plane.
|
ByteBuffer |
get(ByteBuffer buffer)
Store this matrix in column-major order into the supplied
ByteBuffer at the current
buffer position. |
float[] |
get(float[] arr)
Store this matrix into the supplied float array in column-major order.
|
float[] |
get(float[] arr,
int offset)
Store this matrix into the supplied float array in column-major order at the given offset.
|
FloatBuffer |
get(FloatBuffer buffer)
Store this matrix in column-major order into the supplied
FloatBuffer at the current
buffer position. |
ByteBuffer |
get(int index,
ByteBuffer buffer)
Store this matrix in column-major order into the supplied
ByteBuffer starting at the specified
absolute buffer position/index. |
FloatBuffer |
get(int index,
FloatBuffer buffer)
Store this matrix in column-major order into the supplied
FloatBuffer starting at the specified
absolute buffer position/index. |
Matrix4d |
get(Matrix4d dest)
Get the current values of
this matrix and store them into
dest. |
Matrix4f |
get(Matrix4f dest)
Get the current values of
this matrix and store them into
dest. |
Matrix3d |
get3x3(Matrix3d dest)
Get the current values of the upper left 3x3 submatrix of
this matrix and store them into
dest. |
Matrix3f |
get3x3(Matrix3f dest)
Get the current values of the upper left 3x3 submatrix of
this matrix and store them into
dest. |
ByteBuffer |
get4x3(ByteBuffer buffer)
Store the upper 4x3 submatrix in column-major order into the supplied
ByteBuffer at the current
buffer position. |
FloatBuffer |
get4x3(FloatBuffer buffer)
Store the upper 4x3 submatrix in column-major order into the supplied
FloatBuffer at the current
buffer position. |
ByteBuffer |
get4x3(int index,
ByteBuffer buffer)
Store the upper 4x3 submatrix in column-major order into the supplied
ByteBuffer starting at the specified
absolute buffer position/index. |
FloatBuffer |
get4x3(int index,
FloatBuffer buffer)
Store the upper 4x3 submatrix in column-major order into the supplied
FloatBuffer starting at the specified
absolute buffer position/index. |
Matrix4x3f |
get4x3(Matrix4x3f dest)
Get the current values of the upper 4x3 submatrix of
this matrix and store them into
dest. |
ByteBuffer |
get4x3Transposed(ByteBuffer buffer)
Store the upper 4x3 submatrix of
this matrix in row-major order into the supplied ByteBuffer at the current
buffer position. |
FloatBuffer |
get4x3Transposed(FloatBuffer buffer)
Store the upper 4x3 submatrix of
this matrix in row-major order into the supplied FloatBuffer at the current
buffer position. |
ByteBuffer |
get4x3Transposed(int index,
ByteBuffer buffer)
Store the upper 4x3 submatrix of
this matrix in row-major order into the supplied ByteBuffer starting at the specified
absolute buffer position/index. |
FloatBuffer |
get4x3Transposed(int index,
FloatBuffer buffer)
Store the upper 4x3 submatrix of
this matrix in row-major order into the supplied FloatBuffer starting at the specified
absolute buffer position/index. |
Vector3f |
getColumn(int column,
Vector3f dest)
Get the first three components of the column at the given
column index, starting with 0. |
Vector4f |
getColumn(int column,
Vector4f dest)
Get the column at the given
column index, starting with 0. |
Vector3f |
getEulerAnglesZYX(Vector3f dest)
Extract the Euler angles from the rotation represented by the upper left 3x3 submatrix of
this
and store the extracted Euler angles in dest. |
Quaterniond |
getNormalizedRotation(Quaterniond dest)
Get the current values of
this matrix and store the represented rotation
into the given Quaterniond. |
Quaternionf |
getNormalizedRotation(Quaternionf dest)
Get the current values of
this matrix and store the represented rotation
into the given Quaternionf. |
AxisAngle4d |
getRotation(AxisAngle4d dest)
Get the rotational component of
this matrix and store the represented rotation
into the given AxisAngle4d. |
AxisAngle4f |
getRotation(AxisAngle4f dest)
Get the rotational component of
this matrix and store the represented rotation
into the given AxisAngle4f. |
Vector3f |
getRow(int row,
Vector3f dest)
Get the first three components of the row at the given
row index, starting with 0. |
Vector4f |
getRow(int row,
Vector4f dest)
Get the row at the given
row index, starting with 0. |
Vector3f |
getScale(Vector3f dest)
Get the scaling factors of
this matrix for the three base axes. |
Vector3f |
getTranslation(Vector3f dest)
Get only the translation components
(m30, m31, m32) of this matrix and store them in the given vector xyz. |
ByteBuffer |
getTransposed(ByteBuffer buffer)
Store the transpose of this matrix in column-major order into the supplied
ByteBuffer at the current
buffer position. |
FloatBuffer |
getTransposed(FloatBuffer buffer)
Store the transpose of this matrix in column-major order into the supplied
FloatBuffer at the current
buffer position. |
ByteBuffer |
getTransposed(int index,
ByteBuffer buffer)
Store the transpose of this matrix in column-major order into the supplied
ByteBuffer starting at the specified
absolute buffer position/index. |
FloatBuffer |
getTransposed(int index,
FloatBuffer buffer)
Store the transpose of this matrix in column-major order into the supplied
FloatBuffer starting at the specified
absolute buffer position/index. |
Quaterniond |
getUnnormalizedRotation(Quaterniond dest)
Get the current values of
this matrix and store the represented rotation
into the given Quaterniond. |
Quaternionf |
getUnnormalizedRotation(Quaternionf dest)
Get the current values of
this matrix and store the represented rotation
into the given Quaternionf. |
int |
hashCode() |
Matrix4f |
identity()
Reset this matrix to the identity.
|
Matrix4f |
invert()
Invert this matrix.
|
Matrix4f |
invert(Matrix4f dest)
Invert this matrix and write the result into
dest. |
Matrix4f |
invertAffine()
Invert this matrix by assuming that it is an
affine transformation (i.e. |
Matrix4f |
invertAffine(Matrix4f dest)
Invert this matrix by assuming that it is an
affine transformation (i.e. |
Matrix4f |
invertFrustum()
If
this is an arbitrary perspective projection matrix obtained via one of the frustum() methods
or via setFrustum(),
then this method builds the inverse of this. |
Matrix4f |
invertFrustum(Matrix4f dest)
If
this is an arbitrary perspective projection matrix obtained via one of the frustum() methods
or via setFrustum(),
then this method builds the inverse of this and stores it into the given dest. |
Matrix4f |
invertOrtho()
Invert
this orthographic projection matrix. |
Matrix4f |
invertOrtho(Matrix4f dest)
Invert
this orthographic projection matrix and store the result into the given dest. |
Matrix4f |
invertPerspective()
If
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation,
then this method builds the inverse of this. |
Matrix4f |
invertPerspective(Matrix4f dest)
If
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation,
then this method builds the inverse of this and stores it into the given dest. |
Matrix4f |
invertPerspectiveView(Matrix4fc view,
Matrix4f dest)
If
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation
and the given view matrix is affine and has unit scaling (for example by being obtained via lookAt()),
then this method builds the inverse of this * view and stores it into the given dest. |
Matrix4f |
invertPerspectiveView(Matrix4x3fc view,
Matrix4f dest)
If
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation
and the given view matrix has unit scaling,
then this method builds the inverse of this * view and stores it into the given dest. |
boolean |
isAffine()
Determine whether this matrix describes an affine transformation.
|
Matrix4f |
lerp(Matrix4fc other,
float t)
Linearly interpolate
this and other using the given interpolation factor t
and store the result in this. |
Matrix4f |
lerp(Matrix4fc other,
float t,
Matrix4f dest)
Linearly interpolate
this and other using the given interpolation factor t
and store the result in dest. |
Matrix4f |
lookAlong(float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ)
Apply a rotation transformation to this matrix to make
-z point along dir. |
Matrix4f |
lookAlong(float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a rotation transformation to this matrix to make
-z point along dir
and store the result in dest. |
Matrix4f |
lookAlong(Vector3fc dir,
Vector3fc up)
Apply a rotation transformation to this matrix to make
-z point along dir. |
Matrix4f |
lookAlong(Vector3fc dir,
Vector3fc up,
Matrix4f dest)
Apply a rotation transformation to this matrix to make
-z point along dir
and store the result in dest. |
Matrix4f |
lookAt(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ)
Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
that aligns
-z with center - eye. |
Matrix4f |
lookAt(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
that aligns
-z with center - eye and store the result in dest. |
Matrix4f |
lookAt(Vector3fc eye,
Vector3fc center,
Vector3fc up)
Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
that aligns
-z with center - eye. |
Matrix4f |
lookAt(Vector3fc eye,
Vector3fc center,
Vector3fc up,
Matrix4f dest)
Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
that aligns
-z with center - eye and store the result in dest. |
Matrix4f |
lookAtLH(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ)
Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
that aligns
+z with center - eye. |
Matrix4f |
lookAtLH(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
that aligns
+z with center - eye and store the result in dest. |
Matrix4f |
lookAtLH(Vector3fc eye,
Vector3fc center,
Vector3fc up)
Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
that aligns
+z with center - eye. |
Matrix4f |
lookAtLH(Vector3fc eye,
Vector3fc center,
Vector3fc up,
Matrix4f dest)
Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
that aligns
+z with center - eye and store the result in dest. |
Matrix4f |
lookAtPerspective(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a "lookat" transformation to this matrix for a right-handed coordinate system,
that aligns
-z with center - eye and store the result in dest. |
Matrix4f |
lookAtPerspectiveLH(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a "lookat" transformation to this matrix for a left-handed coordinate system,
that aligns
+z with center - eye and store the result in dest. |
float |
m00()
Return the value of the matrix element at column 0 and row 0.
|
Matrix4f |
m00(float m00)
Set the value of the matrix element at column 0 and row 0.
|
float |
m01()
Return the value of the matrix element at column 0 and row 1.
|
Matrix4f |
m01(float m01)
Set the value of the matrix element at column 0 and row 1.
|
float |
m02()
Return the value of the matrix element at column 0 and row 2.
|
Matrix4f |
m02(float m02)
Set the value of the matrix element at column 0 and row 2.
|
float |
m03()
Return the value of the matrix element at column 0 and row 3.
|
Matrix4f |
m03(float m03)
Set the value of the matrix element at column 0 and row 3.
|
float |
m10()
Return the value of the matrix element at column 1 and row 0.
|
Matrix4f |
m10(float m10)
Set the value of the matrix element at column 1 and row 0.
|
float |
m11()
Return the value of the matrix element at column 1 and row 1.
|
Matrix4f |
m11(float m11)
Set the value of the matrix element at column 1 and row 1.
|
float |
m12()
Return the value of the matrix element at column 1 and row 2.
|
Matrix4f |
m12(float m12)
Set the value of the matrix element at column 1 and row 2.
|
float |
m13()
Return the value of the matrix element at column 1 and row 3.
|
Matrix4f |
m13(float m13)
Set the value of the matrix element at column 1 and row 3.
|
float |
m20()
Return the value of the matrix element at column 2 and row 0.
|
Matrix4f |
m20(float m20)
Set the value of the matrix element at column 2 and row 0.
|
float |
m21()
Return the value of the matrix element at column 2 and row 1.
|
Matrix4f |
m21(float m21)
Set the value of the matrix element at column 2 and row 1.
|
float |
m22()
Return the value of the matrix element at column 2 and row 2.
|
Matrix4f |
m22(float m22)
Set the value of the matrix element at column 2 and row 2.
|
float |
m23()
Return the value of the matrix element at column 2 and row 3.
|
Matrix4f |
m23(float m23)
Set the value of the matrix element at column 2 and row 3.
|
float |
m30()
Return the value of the matrix element at column 3 and row 0.
|
Matrix4f |
m30(float m30)
Set the value of the matrix element at column 3 and row 0.
|
float |
m31()
Return the value of the matrix element at column 3 and row 1.
|
Matrix4f |
m31(float m31)
Set the value of the matrix element at column 3 and row 1.
|
float |
m32()
Return the value of the matrix element at column 3 and row 2.
|
Matrix4f |
m32(float m32)
Set the value of the matrix element at column 3 and row 2.
|
float |
m33()
Return the value of the matrix element at column 3 and row 3.
|
Matrix4f |
m33(float m33)
Set the value of the matrix element at column 3 and row 3.
|
Matrix4f |
mul(Matrix3x2fc right)
Multiply this matrix by the supplied
right matrix and store the result in this. |
Matrix4f |
mul(Matrix3x2fc right,
Matrix4f dest)
Multiply this matrix by the supplied
right matrix and store the result in dest. |
Matrix4f |
mul(Matrix4fc right)
Multiply this matrix by the supplied
right matrix and store the result in this. |
Matrix4f |
mul(Matrix4fc right,
Matrix4f dest)
Multiply this matrix by the supplied
right matrix and store the result in dest. |
Matrix4f |
mul(Matrix4x3fc right)
Multiply this matrix by the supplied
right matrix and store the result in this. |
Matrix4f |
mul(Matrix4x3fc right,
Matrix4f dest)
Multiply this matrix by the supplied
right matrix and store the result in dest. |
Matrix4f |
mul4x3ComponentWise(Matrix4fc other)
Component-wise multiply the upper 4x3 submatrices of
this by other. |
Matrix4f |
mul4x3ComponentWise(Matrix4fc other,
Matrix4f dest)
Component-wise multiply the upper 4x3 submatrices of
this by other
and store the result in dest. |
Matrix4f |
mulAffine(Matrix4fc right)
Multiply this matrix by the supplied
right matrix, both of which are assumed to be affine, and store the result in this. |
Matrix4f |
mulAffine(Matrix4fc right,
Matrix4f dest)
Multiply this matrix by the supplied
right matrix, both of which are assumed to be affine, and store the result in dest. |
Matrix4f |
mulAffineR(Matrix4fc right)
Multiply this matrix by the supplied
right matrix, which is assumed to be affine, and store the result in this. |
Matrix4f |
mulAffineR(Matrix4fc right,
Matrix4f dest)
Multiply this matrix by the supplied
right matrix, which is assumed to be affine, and store the result in dest. |
Matrix4f |
mulComponentWise(Matrix4fc other)
Component-wise multiply
this by other. |
Matrix4f |
mulComponentWise(Matrix4fc other,
Matrix4f dest)
Component-wise multiply
this by other and store the result in dest. |
Matrix4f |
mulLocal(Matrix4fc left)
Pre-multiply this matrix by the supplied
left matrix and store the result in this. |
Matrix4f |
mulLocal(Matrix4fc left,
Matrix4f dest)
Pre-multiply this matrix by the supplied
left matrix and store the result in dest. |
Matrix4f |
mulLocalAffine(Matrix4fc left)
Pre-multiply this matrix by the supplied
left matrix, both of which are assumed to be affine, and store the result in this. |
Matrix4f |
mulLocalAffine(Matrix4fc left,
Matrix4f dest)
Pre-multiply this matrix by the supplied
left matrix, both of which are assumed to be affine, and store the result in dest. |
Matrix4f |
mulOrthoAffine(Matrix4fc view)
|
Matrix4f |
mulOrthoAffine(Matrix4fc view,
Matrix4f dest)
Multiply
this orthographic projection matrix by the supplied affine view matrix
and store the result in dest. |
Matrix4f |
mulPerspectiveAffine(Matrix4fc view)
|
Matrix4f |
mulPerspectiveAffine(Matrix4fc view,
Matrix4f dest)
Multiply
this symmetric perspective projection matrix by the supplied affine view matrix and store the result in dest. |
Matrix4f |
mulPerspectiveAffine(Matrix4x3fc view)
Multiply
this symmetric perspective projection matrix by the supplied view matrix. |
Matrix4f |
mulPerspectiveAffine(Matrix4x3fc view,
Matrix4f dest)
Multiply
this symmetric perspective projection matrix by the supplied view matrix and store the result in dest. |
Matrix4f |
mulTranslationAffine(Matrix4fc right,
Matrix4f dest)
Multiply this matrix, which is assumed to only contain a translation, by the supplied
right matrix, which is assumed to be affine, and store the result in dest. |
Matrix4f |
normal()
Compute a normal matrix from the upper left 3x3 submatrix of
this
and store it into the upper left 3x3 submatrix of this. |
Matrix3f |
normal(Matrix3f dest)
Compute a normal matrix from the upper left 3x3 submatrix of
this
and store it into dest. |
Matrix4f |
normal(Matrix4f dest)
Compute a normal matrix from the upper left 3x3 submatrix of
this
and store it into the upper left 3x3 submatrix of dest. |
Matrix4f |
normalize3x3()
Normalize the upper left 3x3 submatrix of this matrix.
|
Matrix3f |
normalize3x3(Matrix3f dest)
Normalize the upper left 3x3 submatrix of this matrix and store the result in
dest. |
Matrix4f |
normalize3x3(Matrix4f dest)
Normalize the upper left 3x3 submatrix of this matrix and store the result in
dest. |
Vector3f |
normalizedPositiveX(Vector3f dir)
Obtain the direction of
+X before the transformation represented by this orthogonal matrix is applied. |
Vector3f |
normalizedPositiveY(Vector3f dir)
Obtain the direction of
+Y before the transformation represented by this orthogonal matrix is applied. |
Vector3f |
normalizedPositiveZ(Vector3f dir)
Obtain the direction of
+Z before the transformation represented by this orthogonal matrix is applied. |
Matrix4f |
obliqueZ(float a,
float b)
Apply an oblique projection transformation to this matrix with the given values for
a and
b. |
Matrix4f |
obliqueZ(float a,
float b,
Matrix4f dest)
Apply an oblique projection transformation to this matrix with the given values for
a and
b and store the result in dest. |
Vector3f |
origin(Vector3f dest)
Obtain the position that gets transformed to the origin by
this matrix. |
Vector3f |
originAffine(Vector3f origin)
Obtain the position that gets transformed to the origin by
this affine matrix. |
Matrix4f |
ortho(float left,
float right,
float bottom,
float top,
float zNear,
float zFar)
Apply an orthographic projection transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
ortho(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Apply an orthographic projection transformation for a right-handed coordinate system using the given NDC z range to this matrix.
|
Matrix4f |
ortho(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
ortho(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
Matrix4f dest)
Apply an orthographic projection transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Matrix4f |
ortho2D(float left,
float right,
float bottom,
float top)
Apply an orthographic projection transformation for a right-handed coordinate system to this matrix.
|
Matrix4f |
ortho2D(float left,
float right,
float bottom,
float top,
Matrix4f dest)
Apply an orthographic projection transformation for a right-handed coordinate system to this matrix
and store the result in
dest. |
Matrix4f |
ortho2DLH(float left,
float right,
float bottom,
float top)
Apply an orthographic projection transformation for a left-handed coordinate system to this matrix.
|
Matrix4f |
ortho2DLH(float left,
float right,
float bottom,
float top,
Matrix4f dest)
Apply an orthographic projection transformation for a left-handed coordinate system to this matrix and store the result in
dest. |
Matrix4f |
orthoCrop(Matrix4fc view,
Matrix4f dest)
Build an ortographic projection transformation that fits the view-projection transformation represented by
this
into the given affine view transformation. |
Matrix4f |
orthoLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar)
Apply an orthographic projection transformation for a left-handed coordiante system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
orthoLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Apply an orthographic projection transformation for a left-handed coordiante system
using the given NDC z range to this matrix.
|
Matrix4f |
orthoLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
orthoLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
Matrix4f dest)
Apply an orthographic projection transformation for a left-handed coordiante system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Matrix4f |
orthoSymmetric(float width,
float height,
float zNear,
float zFar)
Apply a symmetric orthographic projection transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
orthoSymmetric(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne)
Apply a symmetric orthographic projection transformation for a right-handed coordinate system
using the given NDC z range to this matrix.
|
Matrix4f |
orthoSymmetric(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
orthoSymmetric(float width,
float height,
float zNear,
float zFar,
Matrix4f dest)
Apply a symmetric orthographic projection transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Matrix4f |
orthoSymmetricLH(float width,
float height,
float zNear,
float zFar)
Apply a symmetric orthographic projection transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
orthoSymmetricLH(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne)
Apply a symmetric orthographic projection transformation for a left-handed coordinate system
using the given NDC z range to this matrix.
|
Matrix4f |
orthoSymmetricLH(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
orthoSymmetricLH(float width,
float height,
float zNear,
float zFar,
Matrix4f dest)
Apply a symmetric orthographic projection transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Matrix4f |
perspective(float fovy,
float aspect,
float zNear,
float zFar)
Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
perspective(float fovy,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne)
Apply a symmetric perspective projection frustum transformation using for a right-handed coordinate system
the given NDC z range to this matrix.
|
Matrix4f |
perspective(float fovy,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
perspective(float fovy,
float aspect,
float zNear,
float zFar,
Matrix4f dest)
Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
float |
perspectiveFar()
Extract the far clip plane distance from
this perspective projection matrix. |
float |
perspectiveFov()
Return the vertical field-of-view angle in radians of this perspective transformation matrix.
|
Matrix4f |
perspectiveFrustumSlice(float near,
float far,
Matrix4f dest)
Change the near and far clip plane distances of
this perspective frustum transformation matrix
and store the result in dest. |
Matrix4f |
perspectiveLH(float fovy,
float aspect,
float zNear,
float zFar)
Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
perspectiveLH(float fovy,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne)
Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system
using the given NDC z range to this matrix.
|
Matrix4f |
perspectiveLH(float fovy,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
perspectiveLH(float fovy,
float aspect,
float zNear,
float zFar,
Matrix4f dest)
Apply a symmetric perspective projection frustum transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
float |
perspectiveNear()
Extract the near clip plane distance from
this perspective projection matrix. |
Matrix4f |
perspectiveOffCenter(float fovy,
float offAngleX,
float offAngleY,
float aspect,
float zNear,
float zFar)
Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
perspectiveOffCenter(float fovy,
float offAngleX,
float offAngleY,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne)
Apply an asymmetric off-center perspective projection frustum transformation using for a right-handed coordinate system
the given NDC z range to this matrix.
|
Matrix4f |
perspectiveOffCenter(float fovy,
float offAngleX,
float offAngleY,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
perspectiveOffCenter(float fovy,
float offAngleX,
float offAngleY,
float aspect,
float zNear,
float zFar,
Matrix4f dest)
Apply an asymmetric off-center perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Vector3f |
perspectiveOrigin(Vector3f origin)
Compute the eye/origin of the perspective frustum transformation defined by
this matrix,
which can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given origin. |
Matrix4f |
perspectiveRect(float width,
float height,
float zNear,
float zFar)
Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix. |
Matrix4f |
perspectiveRect(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne)
Apply a symmetric perspective projection frustum transformation using for a right-handed coordinate system
the given NDC z range to this matrix.
|
Matrix4f |
perspectiveRect(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne,
Matrix4f 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
dest. |
Matrix4f |
perspectiveRect(float width,
float height,
float zNear,
float zFar,
Matrix4f dest)
Apply a symmetric perspective projection frustum transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1] to this matrix and store the result in dest. |
Matrix4f |
pick(float x,
float y,
float width,
float height,
int[] viewport)
Apply a picking transformation to this matrix using the given window coordinates
(x, y) as the pick center
and the given (width, height) as the size of the picking region in window coordinates. |
Matrix4f |
pick(float x,
float y,
float width,
float height,
int[] viewport,
Matrix4f dest)
Apply a picking transformation to this matrix using the given window coordinates
(x, y) as the pick center
and the given (width, height) as the size of the picking region in window coordinates, and store the result
in dest. |
Vector3f |
positiveX(Vector3f dir)
Obtain the direction of
+X before the transformation represented by this matrix is applied. |
Vector3f |
positiveY(Vector3f dir)
Obtain the direction of
+Y before the transformation represented by this matrix is applied. |
Vector3f |
positiveZ(Vector3f dir)
Obtain the direction of
+Z before the transformation represented by this matrix is applied. |
Vector3f |
project(float x,
float y,
float z,
int[] viewport,
Vector3f winCoordsDest)
Project the given
(x, y, z) position via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest. |
Vector4f |
project(float x,
float y,
float z,
int[] viewport,
Vector4f winCoordsDest)
Project the given
(x, y, z) position via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest. |
Vector3f |
project(Vector3fc position,
int[] viewport,
Vector3f winCoordsDest)
Project the given
position via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest. |
Vector4f |
project(Vector3fc position,
int[] viewport,
Vector4f winCoordsDest)
Project the given
position via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest. |
Matrix4f |
projectedGridRange(Matrix4fc projector,
float sLower,
float sUpper,
Matrix4f dest)
Compute the range matrix for the Projected Grid transformation as described in chapter "2.4.2 Creating the range conversion matrix"
of the paper Real-time water rendering - Introducing the projected grid concept
based on the inverse of the view-projection matrix which is assumed to be
this, and store that range matrix into dest. |
static void |
projViewFromRectangle(Vector3f eye,
Vector3f p,
Vector3f x,
Vector3f y,
float nearFarDist,
boolean zeroToOne,
Matrix4f projDest,
Matrix4f viewDest)
Create a view and projection matrix from a given
eye position, a given bottom left corner position p of the near plane rectangle
and the extents of the near plane rectangle along its local x and y axes, and store the resulting matrices
in projDest and viewDest. |
int |
properties()
Return the assumed properties of this matrix.
|
void |
readExternal(ObjectInput in) |
Matrix4f |
reflect(float a,
float b,
float c,
float d)
Apply a mirror/reflection transformation to this matrix that reflects about the given plane
specified via the equation
x*a + y*b + z*c + d = 0. |
Matrix4f |
reflect(float nx,
float ny,
float nz,
float px,
float py,
float 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.
|
Matrix4f |
reflect(float nx,
float ny,
float nz,
float px,
float py,
float pz,
Matrix4f dest)
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, and store the result in
dest. |
Matrix4f |
reflect(float a,
float b,
float c,
float d,
Matrix4f dest)
Apply a mirror/reflection transformation to this matrix that reflects about the given plane
specified via the equation
x*a + y*b + z*c + d = 0 and store the result in dest. |
Matrix4f |
reflect(Quaternionfc orientation,
Vector3fc 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.
|
Matrix4f |
reflect(Quaternionfc orientation,
Vector3fc point,
Matrix4f dest)
Apply a mirror/reflection transformation to this matrix that reflects about a plane
specified via the plane orientation and a point on the plane, and store the result in
dest. |
Matrix4f |
reflect(Vector3fc normal,
Vector3fc 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.
|
Matrix4f |
reflect(Vector3fc normal,
Vector3fc point,
Matrix4f dest)
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, and store the result in
dest. |
Matrix4f |
reflection(float a,
float b,
float c,
float d)
Set this matrix to a mirror/reflection transformation that reflects about the given plane
specified via the equation
x*a + y*b + z*c + d = 0. |
Matrix4f |
reflection(float nx,
float ny,
float nz,
float px,
float py,
float 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.
|
Matrix4f |
reflection(Quaternionfc orientation,
Vector3fc 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.
|
Matrix4f |
reflection(Vector3fc normal,
Vector3fc 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.
|
Matrix4f |
rotate(AxisAngle4f axisAngle)
Apply a rotation transformation, rotating about the given
AxisAngle4f, to this matrix. |
Matrix4f |
rotate(AxisAngle4f axisAngle,
Matrix4f dest)
Apply a rotation transformation, rotating about the given
AxisAngle4f and store the result in dest. |
Matrix4f |
rotate(float ang,
float x,
float y,
float z)
Apply rotation to this matrix by rotating the given amount of radians
about the specified
(x, y, z) axis. |
Matrix4f |
rotate(float ang,
float x,
float y,
float z,
Matrix4f dest)
Apply rotation to this matrix by rotating the given amount of radians
about the specified
(x, y, z) axis and store the result in dest. |
Matrix4f |
rotate(float angle,
Vector3fc axis)
Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.
|
Matrix4f |
rotate(float angle,
Vector3fc axis,
Matrix4f dest)
Apply a rotation transformation, rotating the given radians about the specified axis and store the result in
dest. |
Matrix4f |
rotate(Quaternionfc quat)
Apply the rotation transformation of the given
Quaternionfc to this matrix. |
Matrix4f |
rotate(Quaternionfc quat,
Matrix4f dest)
Apply the rotation transformation of the given
Quaternionfc to this matrix and store
the result in dest. |
Matrix4f |
rotateAffine(float ang,
float x,
float y,
float z)
Apply rotation to this
affine matrix by rotating the given amount of radians
about the specified (x, y, z) axis. |
Matrix4f |
rotateAffine(float ang,
float x,
float y,
float z,
Matrix4f dest)
Apply rotation to this
affine matrix by rotating the given amount of radians
about the specified (x, y, z) axis and store the result in dest. |
Matrix4f |
rotateAffine(Quaternionfc quat)
Apply the rotation transformation of the given
Quaternionfc to this matrix. |
Matrix4f |
rotateAffine(Quaternionfc quat,
Matrix4f dest)
Apply the rotation transformation of the given
Quaternionfc to this affine matrix and store
the result in dest. |
Matrix4f |
rotateAffineXYZ(float angleX,
float angleY,
float angleZ)
Apply rotation of
angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
rotateAffineXYZ(float angleX,
float angleY,
float angleZ,
Matrix4f dest)
Apply rotation of
angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest. |
Matrix4f |
rotateAffineYXZ(float angleY,
float angleX,
float angleZ)
Apply rotation of
angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
rotateAffineYXZ(float angleY,
float angleX,
float angleZ,
Matrix4f dest)
Apply rotation of
angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest. |
Matrix4f |
rotateAffineZYX(float angleZ,
float angleY,
float angleX)
Apply rotation of
angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis. |
Matrix4f |
rotateAffineZYX(float angleZ,
float angleY,
float angleX,
Matrix4f dest)
Apply rotation of
angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis and store the result in dest. |
Matrix4f |
rotateAround(Quaternionfc quat,
float ox,
float oy,
float oz)
Apply the rotation transformation of the given
Quaternionfc to this matrix while using (ox, oy, oz) as the rotation origin. |
Matrix4f |
rotateAround(Quaternionfc quat,
float ox,
float oy,
float oz,
Matrix4f dest)
Apply the rotation - and possibly scaling - transformation of the given
Quaternionfc to this matrix while using (ox, oy, oz) as the rotation origin,
and store the result in dest. |
Matrix4f |
rotateAroundAffine(Quaternionfc quat,
float ox,
float oy,
float oz,
Matrix4f dest)
Apply the rotation - and possibly scaling - transformation of the given
Quaternionfc to this affine
matrix while using (ox, oy, oz) as the rotation origin, and store the result in dest. |
Matrix4f |
rotateAroundLocal(Quaternionfc quat,
float ox,
float oy,
float oz)
Pre-multiply the rotation transformation of the given
Quaternionfc to this matrix while using (ox, oy, oz)
as the rotation origin. |
Matrix4f |
rotateAroundLocal(Quaternionfc quat,
float ox,
float oy,
float oz,
Matrix4f dest)
Pre-multiply the rotation - and possibly scaling - transformation of the given
Quaternionfc to this matrix while using (ox, oy, oz)
as the rotation origin, and store the result in dest. |
Matrix4f |
rotateLocal(float ang,
float x,
float y,
float z)
Pre-multiply a rotation to this matrix by rotating the given amount of radians
about the specified
(x, y, z) axis. |
Matrix4f |
rotateLocal(float ang,
float x,
float y,
float z,
Matrix4f dest)
Pre-multiply a rotation to this matrix by rotating the given amount of radians
about the specified
(x, y, z) axis and store the result in dest. |
Matrix4f |
rotateLocal(Quaternionfc quat)
Pre-multiply the rotation transformation of the given
Quaternionfc to this matrix. |
Matrix4f |
rotateLocal(Quaternionfc quat,
Matrix4f dest)
Pre-multiply the rotation transformation of the given
Quaternionfc to this matrix and store
the result in dest. |
Matrix4f |
rotateLocalX(float ang)
Pre-multiply a rotation to this matrix by rotating the given amount of radians about the X axis.
|
Matrix4f |
rotateLocalX(float ang,
Matrix4f 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
dest. |
Matrix4f |
rotateLocalY(float ang)
Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y axis.
|
Matrix4f |
rotateLocalY(float ang,
Matrix4f 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
dest. |
Matrix4f |
rotateLocalZ(float ang)
Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Z axis.
|
Matrix4f |
rotateLocalZ(float ang,
Matrix4f 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
dest. |
Matrix4f |
rotateTowards(float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ)
Apply a model transformation to this matrix for a right-handed coordinate system,
that aligns the local
+Z axis with (dirX, dirY, dirZ). |
Matrix4f |
rotateTowards(float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a model transformation to this matrix for a right-handed coordinate system,
that aligns the local
+Z axis with (dirX, dirY, dirZ)
and store the result in dest. |
Matrix4f |
rotateTowards(Vector3fc dir,
Vector3fc up)
Apply a model transformation to this matrix for a right-handed coordinate system,
that aligns the local
+Z axis with dir. |
Matrix4f |
rotateTowards(Vector3fc dir,
Vector3fc up,
Matrix4f dest)
Apply a model transformation to this matrix for a right-handed coordinate system,
that aligns the local
+Z axis with dir
and store the result in dest. |
Matrix4f |
rotateTowardsXY(float dirX,
float dirY)
Apply rotation about the Z axis to align the local
+X towards (dirX, dirY). |
Matrix4f |
rotateTowardsXY(float dirX,
float dirY,
Matrix4f dest)
Apply rotation about the Z axis to align the local
+X towards (dirX, dirY) and store the result in dest. |
Matrix4f |
rotateTranslation(float ang,
float x,
float y,
float z,
Matrix4f dest)
Apply rotation to this matrix, which is assumed to only contain a translation, by rotating the given amount of radians
about the specified
(x, y, z) axis and store the result in dest. |
Matrix4f |
rotateTranslation(Quaternionfc quat,
Matrix4f dest)
Apply the rotation transformation of the given
Quaternionfc to this matrix, which is assumed to only contain a translation, and store
the result in dest. |
Matrix4f |
rotateX(float ang)
Apply rotation about the X axis to this matrix by rotating the given amount of radians.
|
Matrix4f |
rotateX(float ang,
Matrix4f dest)
Apply rotation about the X axis to this matrix by rotating the given amount of radians
and store the result in
dest. |
Matrix4f |
rotateXYZ(float angleX,
float angleY,
float angleZ)
Apply rotation of
angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
rotateXYZ(float angleX,
float angleY,
float angleZ,
Matrix4f dest)
Apply rotation of
angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest. |
Matrix4f |
rotateXYZ(Vector3f angles)
Apply rotation of
angles.x radians about the X axis, followed by a rotation of angles.y radians about the Y axis and
followed by a rotation of angles.z radians about the Z axis. |
Matrix4f |
rotateY(float ang)
Apply rotation about the Y axis to this matrix by rotating the given amount of radians.
|
Matrix4f |
rotateY(float ang,
Matrix4f dest)
Apply rotation about the Y axis to this matrix by rotating the given amount of radians
and store the result in
dest. |
Matrix4f |
rotateYXZ(float angleY,
float angleX,
float angleZ)
Apply rotation of
angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
rotateYXZ(float angleY,
float angleX,
float angleZ,
Matrix4f dest)
Apply rotation of
angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest. |
Matrix4f |
rotateYXZ(Vector3f angles)
Apply rotation of
angles.y radians about the Y axis, followed by a rotation of angles.x radians about the X axis and
followed by a rotation of angles.z radians about the Z axis. |
Matrix4f |
rotateZ(float ang)
Apply rotation about the Z axis to this matrix by rotating the given amount of radians.
|
Matrix4f |
rotateZ(float ang,
Matrix4f dest)
Apply rotation about the Z axis to this matrix by rotating the given amount of radians
and store the result in
dest. |
Matrix4f |
rotateZYX(float angleZ,
float angleY,
float angleX)
Apply rotation of
angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis. |
Matrix4f |
rotateZYX(float angleZ,
float angleY,
float angleX,
Matrix4f dest)
Apply rotation of
angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis and store the result in dest. |
Matrix4f |
rotateZYX(Vector3f angles)
Apply rotation of
angles.z radians about the Z axis, followed by a rotation of angles.y radians about the Y axis and
followed by a rotation of angles.x radians about the X axis. |
Matrix4f |
rotation(AxisAngle4f axisAngle)
Set this matrix to a rotation transformation using the given
AxisAngle4f. |
Matrix4f |
rotation(float angle,
float x,
float y,
float z)
Set this matrix to a rotation matrix which rotates the given radians about a given axis.
|
Matrix4f |
rotation(float angle,
Vector3fc axis)
Set this matrix to a rotation matrix which rotates the given radians about a given axis.
|
Matrix4f |
rotation(Quaternionfc quat)
Set this matrix to the rotation transformation of the given
Quaternionfc. |
Matrix4f |
rotationAround(Quaternionfc quat,
float ox,
float oy,
float oz)
Set this matrix to a transformation composed of a rotation of the specified
Quaternionfc while using (ox, oy, oz) as the rotation origin. |
Matrix4f |
rotationTowards(float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ)
Set this matrix to a model transformation for a right-handed coordinate system,
that aligns the local
-z axis with (dirX, dirY, dirZ). |
Matrix4f |
rotationTowards(Vector3fc dir,
Vector3fc up)
Set this matrix to a model transformation for a right-handed coordinate system,
that aligns the local
-z axis with dir. |
Matrix4f |
rotationTowardsXY(float dirX,
float dirY)
Set this matrix to a rotation transformation about the Z axis to align the local
+X towards (dirX, dirY). |
Matrix4f |
rotationX(float ang)
Set this matrix to a rotation transformation about the X axis.
|
Matrix4f |
rotationXYZ(float angleX,
float angleY,
float angleZ)
Set this matrix to a rotation of
angleX radians about the X axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
rotationY(float ang)
Set this matrix to a rotation transformation about the Y axis.
|
Matrix4f |
rotationYXZ(float angleY,
float angleX,
float angleZ)
Set this matrix to a rotation of
angleY radians about the Y axis, followed by a rotation
of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
rotationZ(float ang)
Set this matrix to a rotation transformation about the Z axis.
|
Matrix4f |
rotationZYX(float angleZ,
float angleY,
float angleX)
Set this matrix to a rotation of
angleZ radians about the Z axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis. |
Matrix4f |
scale(float xyz)
Apply scaling to this matrix by uniformly scaling all base axes by the given
xyz factor. |
Matrix4f |
scale(float x,
float y,
float z)
Apply scaling to this matrix by scaling the base axes by the given sx,
sy and sz factors.
|
Matrix4f |
scale(float x,
float y,
float z,
Matrix4f dest)
Apply scaling to
this matrix by scaling the base axes by the given x,
y and z factors and store the result in dest. |
Matrix4f |
scale(float xyz,
Matrix4f dest)
Apply scaling to this matrix by uniformly scaling all base axes by the given
xyz factor
and store the result in dest. |
Matrix4f |
scale(Vector3fc xyz)
Apply scaling to this matrix by scaling the base axes by the given
xyz.x,
xyz.y and xyz.z factors, respectively. |
Matrix4f |
scale(Vector3fc xyz,
Matrix4f dest)
Apply scaling to
this matrix by scaling the base axes by the given xyz.x,
xyz.y and xyz.z factors, respectively and store the result in dest. |
Matrix4f |
scaleAround(float factor,
float ox,
float oy,
float oz)
Apply scaling to this matrix by scaling all three base axes by the given
factor
while using (ox, oy, oz) as the scaling origin. |
Matrix4f |
scaleAround(float sx,
float sy,
float sz,
float ox,
float oy,
float oz)
Apply scaling to this matrix by scaling the base axes by the given sx,
sy and sz factors while using
(ox, oy, oz) as the scaling origin. |
Matrix4f |
scaleAround(float sx,
float sy,
float sz,
float ox,
float oy,
float oz,
Matrix4f dest)
Apply scaling to
this matrix by scaling the base axes by the given sx,
sy and sz factors while using (ox, oy, oz) as the scaling origin,
and store the result in dest. |
Matrix4f |
scaleAround(float factor,
float ox,
float oy,
float oz,
Matrix4f dest)
Apply scaling to this matrix by scaling all three base axes by the given
factor
while using (ox, oy, oz) as the scaling origin,
and store the result in dest. |
Matrix4f |
scaleAroundLocal(float factor,
float ox,
float oy,
float oz)
Pre-multiply scaling to this matrix by scaling all three base axes by the given
factor
while using (ox, oy, oz) as the scaling origin. |
Matrix4f |
scaleAroundLocal(float sx,
float sy,
float sz,
float ox,
float oy,
float oz)
Pre-multiply scaling to this matrix by scaling the base axes by the given sx,
sy and sz factors while using
(ox, oy, oz) as the scaling origin. |
Matrix4f |
scaleAroundLocal(float sx,
float sy,
float sz,
float ox,
float oy,
float oz,
Matrix4f dest)
Pre-multiply scaling to
this matrix by scaling the base axes by the given sx,
sy and sz factors while using the given (ox, oy, oz) as the scaling origin,
and store the result in dest. |
Matrix4f |
scaleAroundLocal(float factor,
float ox,
float oy,
float oz,
Matrix4f dest)
Pre-multiply scaling to this matrix by scaling all three base axes by the given
factor
while using (ox, oy, oz) as the scaling origin,
and store the result in dest. |
Matrix4f |
scaleLocal(float xyz)
Pre-multiply scaling to this matrix by scaling the base axes by the given xyz factor.
|
Matrix4f |
scaleLocal(float x,
float y,
float z)
Pre-multiply scaling to this matrix by scaling the base axes by the given x,
y and z factors.
|
Matrix4f |
scaleLocal(float x,
float y,
float z,
Matrix4f dest)
Pre-multiply scaling to
this matrix by scaling the base axes by the given x,
y and z factors and store the result in dest. |
Matrix4f |
scaleLocal(float xyz,
Matrix4f dest)
Pre-multiply scaling to
this matrix by scaling all base axes by the given xyz factor,
and store the result in dest. |
Matrix4f |
scaleXY(float x,
float y)
Apply scaling to this matrix by scaling the X axis by
x and the Y axis by y. |
Matrix4f |
scaleXY(float x,
float y,
Matrix4f dest)
Apply scaling to this matrix by by scaling the X axis by
x and the Y axis by y
and store the result in dest. |
Matrix4f |
scaling(float factor)
Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given factor.
|
Matrix4f |
scaling(float x,
float y,
float z)
Set this matrix to be a simple scale matrix.
|
Matrix4f |
scaling(Vector3fc xyz)
Set this matrix to be a simple scale matrix which scales the base axes by
xyz.x, xyz.y and xyz.z respectively. |
Matrix4f |
set(AxisAngle4d axisAngle)
Set this matrix to be equivalent to the rotation specified by the given
AxisAngle4d. |
Matrix4f |
set(AxisAngle4f axisAngle)
Set this matrix to be equivalent to the rotation specified by the given
AxisAngle4f. |
Matrix4f |
set(ByteBuffer buffer)
Set the values of this matrix by reading 16 float values from the given
ByteBuffer in column-major order,
starting at its current position. |
Matrix4f |
set(float[] m)
Set the values in the matrix using a float array that contains the matrix elements in column-major order.
|
Matrix4f |
set(float[] m,
int off)
Set the values in the matrix using a float array that contains the matrix elements in column-major order.
|
Matrix4f |
set(FloatBuffer buffer)
Set the values of this matrix by reading 16 float values from the given
FloatBuffer in column-major order,
starting at its current position. |
Matrix4f |
set(float m00,
float m01,
float m02,
float m03,
float m10,
float m11,
float m12,
float m13,
float m20,
float m21,
float m22,
float m23,
float m30,
float m31,
float m32,
float m33)
Set the values within this matrix to the supplied float values.
|
Matrix4f |
set(Matrix3fc mat)
|
Matrix4f |
set(Matrix4dc m)
Store the values of the given matrix
m into this matrix. |
Matrix4f |
set(Matrix4fc m)
Store the values of the given matrix
m into this matrix. |
Matrix4f |
set(Matrix4x3fc m)
Store the values of the given matrix
m into this matrix
and set the other matrix elements to identity. |
Matrix4f |
set(Quaterniondc q)
Set this matrix to be equivalent to the rotation specified by the given
Quaterniondc. |
Matrix4f |
set(Quaternionfc q)
Set this matrix to be equivalent to the rotation specified by the given
Quaternionfc. |
Matrix4f |
set(Vector4fc col0,
Vector4fc col1,
Vector4fc col2,
Vector4fc col3)
Set the four columns of this matrix to the supplied vectors, respectively.
|
Matrix4f |
set3x3(Matrix3fc mat)
|
Matrix4f |
set3x3(Matrix4f mat)
|
Matrix4f |
set4x3(Matrix4f mat)
|
Matrix4f |
set4x3(Matrix4x3fc mat)
Set the upper 4x3 submatrix of this
Matrix4f to the given Matrix4x3fc
and don't change the other elements. |
Matrix4f |
setColumn(int column,
Vector4fc src)
Set the column at the given
column index, starting with 0. |
Matrix4f |
setFromIntrinsic(float alphaX,
float alphaY,
float gamma,
float u0,
float v0,
int imgWidth,
int imgHeight,
float near,
float far)
Set this matrix to represent a perspective projection equivalent to the given intrinsic camera calibration parameters.
|
Matrix4f |
setFrustum(float left,
float right,
float bottom,
float top,
float zNear,
float 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
[-1..+1]. |
Matrix4f |
setFrustum(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be an arbitrary perspective projection frustum transformation for a right-handed coordinate system
using the given NDC z range.
|
Matrix4f |
setFrustumLH(float left,
float right,
float bottom,
float top,
float zNear,
float 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
[-1..+1]. |
Matrix4f |
setFrustumLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean 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
[-1..+1]. |
Matrix4f |
setLookAlong(float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ)
Set this matrix to a rotation transformation to make
-z
point along dir. |
Matrix4f |
setLookAlong(Vector3fc dir,
Vector3fc up)
Set this matrix to a rotation transformation to make
-z
point along dir. |
Matrix4f |
setLookAt(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ)
Set this matrix to be a "lookat" transformation for a right-handed coordinate system,
that aligns
-z with center - eye. |
Matrix4f |
setLookAt(Vector3fc eye,
Vector3fc center,
Vector3fc up)
Set this matrix to be a "lookat" transformation for a right-handed coordinate system, that aligns
-z with center - eye. |
Matrix4f |
setLookAtLH(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ)
Set this matrix to be a "lookat" transformation for a left-handed coordinate system,
that aligns
+z with center - eye. |
Matrix4f |
setLookAtLH(Vector3fc eye,
Vector3fc center,
Vector3fc up)
Set this matrix to be a "lookat" transformation for a left-handed coordinate system, that aligns
+z with center - eye. |
Matrix4f |
setOrtho(float left,
float right,
float bottom,
float top,
float zNear,
float zFar)
Set this matrix to be an orthographic projection transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1]. |
Matrix4f |
setOrtho(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be an orthographic projection transformation for a right-handed coordinate system
using the given NDC z range.
|
Matrix4f |
setOrtho2D(float left,
float right,
float bottom,
float top)
Set this matrix to be an orthographic projection transformation for a right-handed coordinate system.
|
Matrix4f |
setOrtho2DLH(float left,
float right,
float bottom,
float top)
Set this matrix to be an orthographic projection transformation for a left-handed coordinate system.
|
Matrix4f |
setOrthoLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar)
Set this matrix to be an orthographic projection transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1]. |
Matrix4f |
setOrthoLH(float left,
float right,
float bottom,
float top,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be an orthographic projection transformation for a left-handed coordinate system
using the given NDC z range.
|
Matrix4f |
setOrthoSymmetric(float width,
float height,
float zNear,
float zFar)
Set this matrix to be a symmetric orthographic projection transformation for a right-handed coordinate system
using OpenGL's NDC z range of
[-1..+1]. |
Matrix4f |
setOrthoSymmetric(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be a symmetric orthographic projection transformation for a right-handed coordinate system using the given NDC z range.
|
Matrix4f |
setOrthoSymmetricLH(float width,
float height,
float zNear,
float zFar)
Set this matrix to be a symmetric orthographic projection transformation for a left-handed coordinate system
using OpenGL's NDC z range of
[-1..+1]. |
Matrix4f |
setOrthoSymmetricLH(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be a symmetric orthographic projection transformation for a left-handed coordinate system using the given NDC z range.
|
Matrix4f |
setPerspective(float fovy,
float aspect,
float zNear,
float 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
[-1..+1]. |
Matrix4f |
setPerspective(float fovy,
float aspect,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system
using the given NDC z range.
|
Matrix4f |
setPerspectiveLH(float fovy,
float aspect,
float zNear,
float 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
[-1..+1]. |
Matrix4f |
setPerspectiveLH(float fovy,
float aspect,
float zNear,
float zFar,
boolean 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
[-1..+1]. |
Matrix4f |
setPerspectiveOffCenter(float fovy,
float offAngleX,
float offAngleY,
float aspect,
float zNear,
float 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
[-1..+1]. |
Matrix4f |
setPerspectiveOffCenter(float fovy,
float offAngleX,
float offAngleY,
float aspect,
float zNear,
float zFar,
boolean 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.
|
Matrix4f |
setPerspectiveRect(float width,
float height,
float zNear,
float 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
[-1..+1]. |
Matrix4f |
setPerspectiveRect(float width,
float height,
float zNear,
float zFar,
boolean zZeroToOne)
Set this matrix to be a symmetric perspective projection frustum transformation for a right-handed coordinate system
using the given NDC z range.
|
Matrix4f |
setRotationXYZ(float angleX,
float angleY,
float angleZ)
Set only the upper left 3x3 submatrix of this matrix to a rotation of
angleX radians about the X axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
setRotationYXZ(float angleY,
float angleX,
float angleZ)
Set only the upper left 3x3 submatrix of this matrix to a rotation of
angleY radians about the Y axis, followed by a rotation
of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis. |
Matrix4f |
setRotationZYX(float angleZ,
float angleY,
float angleX)
Set only the upper left 3x3 submatrix of this matrix to a rotation of
angleZ radians about the Z axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis. |
Matrix4f |
setRow(int row,
Vector4fc src)
Set the row at the given
row index, starting with 0. |
Matrix4f |
setTranslation(float x,
float y,
float z)
Set only the translation components
(m30, m31, m32) of this matrix to the given values (x, y, z). |
Matrix4f |
setTranslation(Vector3fc xyz)
Set only the translation components
(m30, m31, m32) of this matrix to the values (xyz.x, xyz.y, xyz.z). |
Matrix4f |
shadow(float lightX,
float lightY,
float lightZ,
float lightW,
float a,
float b,
float c,
float d)
Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation
x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW). |
Matrix4f |
shadow(float lightX,
float lightY,
float lightZ,
float lightW,
float a,
float b,
float c,
float d,
Matrix4f dest)
Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation
x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW)
and store the result in dest. |
Matrix4f |
shadow(float lightX,
float lightY,
float lightZ,
float lightW,
Matrix4f planeTransform)
Apply a projection transformation to this matrix that projects onto the plane with the general plane equation
y = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW). |
Matrix4f |
shadow(float lightX,
float lightY,
float lightZ,
float lightW,
Matrix4fc planeTransform,
Matrix4f dest)
Apply a projection transformation to this matrix that projects onto the plane with the general plane equation
y = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW)
and store the result in dest. |
Matrix4f |
shadow(Vector4f light,
float a,
float b,
float c,
float d)
Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation
x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction light. |
Matrix4f |
shadow(Vector4f light,
float a,
float b,
float c,
float d,
Matrix4f dest)
Apply a projection transformation to this matrix that projects onto the plane specified via the general plane equation
x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction light
and store the result in dest. |
Matrix4f |
shadow(Vector4f light,
Matrix4f planeTransform)
Apply a projection transformation to this matrix that projects onto the plane with the general plane equation
y = 0 as if casting a shadow from a given light position/direction light. |
Matrix4f |
shadow(Vector4f light,
Matrix4fc planeTransform,
Matrix4f dest)
Apply a projection transformation to this matrix that projects onto the plane with the general plane equation
y = 0 as if casting a shadow from a given light position/direction light
and store the result in dest. |
Matrix4f |
sub(Matrix4fc subtrahend)
Component-wise subtract
subtrahend from this. |
Matrix4f |
sub(Matrix4fc subtrahend,
Matrix4f dest)
Component-wise subtract
subtrahend from this and store the result in dest. |
Matrix4f |
sub4x3(Matrix4f subtrahend)
Component-wise subtract the upper 4x3 submatrices of
subtrahend from this. |
Matrix4f |
sub4x3(Matrix4fc subtrahend,
Matrix4f dest)
Component-wise subtract the upper 4x3 submatrices of
subtrahend from this
and store the result in dest. |
Matrix4f |
swap(Matrix4f other)
Exchange the values of
this matrix with the given other matrix. |
boolean |
testAab(float minX,
float minY,
float minZ,
float maxX,
float maxY,
float maxZ)
Test whether the given axis-aligned box is partly or completely within or outside of the frustum defined by
this matrix. |
boolean |
testPoint(float x,
float y,
float z)
Test whether the given point
(x, y, z) is within the frustum defined by this matrix. |
boolean |
testSphere(float x,
float y,
float z,
float r)
Test whether the given sphere is partly or completely within or outside of the frustum defined by
this matrix. |
String |
toString()
Return a string representation of this matrix.
|
String |
toString(NumberFormat formatter)
Return a string representation of this matrix by formatting the matrix elements with the given
NumberFormat. |
Vector4f |
transform(float x,
float y,
float z,
float w,
Vector4f dest)
Transform/multiply the vector
(x, y, z, w) by this matrix and store the result in dest. |
Vector4f |
transform(Vector4f v)
Transform/multiply the given vector by this matrix and store the result in that vector.
|
Vector4f |
transform(Vector4fc v,
Vector4f dest)
Transform/multiply the given vector by this matrix and store the result in
dest. |
Matrix4f |
transformAab(float minX,
float minY,
float minZ,
float maxX,
float maxY,
float maxZ,
Vector3f outMin,
Vector3f outMax)
Transform the axis-aligned box given as the minimum corner
(minX, minY, minZ) and maximum corner (maxX, maxY, maxZ)
by this affine matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin
and maximum corner stored in outMax. |
Matrix4f |
transformAab(Vector3fc min,
Vector3fc max,
Vector3f outMin,
Vector3f outMax)
Transform the axis-aligned box given as the minimum corner
min and maximum corner max
by this affine matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin
and maximum corner stored in outMax. |
Vector4f |
transformAffine(float x,
float y,
float z,
float w,
Vector4f dest)
Transform/multiply the 4D-vector
(x, y, z, w) by assuming that this matrix represents an affine transformation
(i.e. |
Vector4f |
transformAffine(Vector4f v)
Transform/multiply the given 4D-vector by assuming that
this matrix represents an affine transformation
(i.e. |
Vector4f |
transformAffine(Vector4fc v,
Vector4f dest)
Transform/multiply the given 4D-vector by assuming that
this matrix represents an affine transformation
(i.e. |
Vector3f |
transformDirection(float x,
float y,
float z,
Vector3f dest)
Transform/multiply the given 3D-vector
(x, y, z), as if it was a 4D-vector with w=0, by
this matrix and store the result in dest. |
Vector3f |
transformDirection(Vector3f v)
Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by
this matrix and store the result in that vector.
|
Vector3f |
transformDirection(Vector3fc v,
Vector3f dest)
Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=0, by
this matrix and store the result in
dest. |
Vector3f |
transformPosition(float x,
float y,
float z,
Vector3f dest)
Transform/multiply the 3D-vector
(x, y, z), as if it was a 4D-vector with w=1, by
this matrix and store the result in dest. |
Vector3f |
transformPosition(Vector3f v)
Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by
this matrix and store the result in that vector.
|
Vector3f |
transformPosition(Vector3fc v,
Vector3f dest)
Transform/multiply the given 3D-vector, as if it was a 4D-vector with w=1, by
this matrix and store the result in
dest. |
Vector4f |
transformProject(float x,
float y,
float z,
float w,
Vector4f dest)
Transform/multiply the vector
(x, y, z, w) by this matrix, perform perspective divide and store the result in dest. |
Vector3f |
transformProject(float x,
float y,
float z,
Vector3f dest)
Transform/multiply the vector
(x, y, z) by this matrix, perform perspective divide and store the result in dest. |
Vector3f |
transformProject(Vector3f v)
Transform/multiply the given vector by this matrix, perform perspective divide and store the result in that vector.
|
Vector3f |
transformProject(Vector3fc v,
Vector3f dest)
Transform/multiply the given vector by this matrix, perform perspective divide and store the result in
dest. |
Vector4f |
transformProject(Vector4f v)
Transform/multiply the given vector by this matrix, perform perspective divide and store the result in that vector.
|
Vector4f |
transformProject(Vector4fc v,
Vector4f dest)
Transform/multiply the given vector by this matrix, perform perspective divide and store the result in
dest. |
Matrix4f |
translate(float x,
float y,
float z)
Apply a translation to this matrix by translating by the given number of
units in x, y and z.
|
Matrix4f |
translate(float x,
float y,
float z,
Matrix4f 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
dest. |
Matrix4f |
translate(Vector3fc offset)
Apply a translation to this matrix by translating by the given number of
units in x, y and z.
|
Matrix4f |
translate(Vector3fc offset,
Matrix4f 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
dest. |
Matrix4f |
translateLocal(float x,
float y,
float z)
Pre-multiply a translation to this matrix by translating by the given number of
units in x, y and z.
|
Matrix4f |
translateLocal(float x,
float y,
float z,
Matrix4f 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
dest. |
Matrix4f |
translateLocal(Vector3fc offset)
Pre-multiply a translation to this matrix by translating by the given number of
units in x, y and z.
|
Matrix4f |
translateLocal(Vector3fc offset,
Matrix4f 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
dest. |
Matrix4f |
translation(float x,
float y,
float z)
Set this matrix to be a simple translation matrix.
|
Matrix4f |
translation(Vector3fc offset)
Set this matrix to be a simple translation matrix.
|
Matrix4f |
translationRotate(float tx,
float ty,
float tz,
float qx,
float qy,
float qz,
float qw)
Set
this matrix to T * R, where T is a translation by the given (tx, ty, tz) and
R is a rotation - and possibly scaling - transformation specified by the quaternion (qx, qy, qz, qw). |
Matrix4f |
translationRotate(float tx,
float ty,
float tz,
Quaternionfc quat)
Set
this matrix to T * R, where T is a translation by the given (tx, ty, tz) and
R is a rotation - and possibly scaling - transformation specified by the given quaternion. |
Matrix4f |
translationRotateScale(float tx,
float ty,
float tz,
float qx,
float qy,
float qz,
float qw,
float scale)
Set
this matrix to T * R * S, where T is a translation by the given (tx, ty, tz),
R is a rotation transformation specified by the quaternion (qx, qy, qz, qw), and S is a scaling transformation
which scales all three axes by scale. |
Matrix4f |
translationRotateScale(float tx,
float ty,
float tz,
float qx,
float qy,
float qz,
float qw,
float sx,
float sy,
float sz)
Set
this matrix to T * R * S, where T is a translation by the given (tx, ty, tz),
R is a rotation transformation specified by the quaternion (qx, qy, qz, qw), and S is a scaling transformation
which scales the three axes x, y and z by (sx, sy, sz). |
Matrix4f |
translationRotateScale(Vector3fc translation,
Quaternionfc quat,
float scale)
Set
this matrix to T * R * S, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales all three axes by scale. |
Matrix4f |
translationRotateScale(Vector3fc translation,
Quaternionfc quat,
Vector3fc scale)
Set
this matrix to T * R * S, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales the axes by scale. |
Matrix4f |
translationRotateScaleInvert(float tx,
float ty,
float tz,
float qx,
float qy,
float qz,
float qw,
float sx,
float sy,
float sz)
Set
this matrix to (T * R * S)-1, where T is a translation by the given (tx, ty, tz),
R is a rotation transformation specified by the quaternion (qx, qy, qz, qw), and S is a scaling transformation
which scales the three axes x, y and z by (sx, sy, sz). |
Matrix4f |
translationRotateScaleInvert(Vector3fc translation,
Quaternionfc quat,
float scale)
Set
this matrix to (T * R * S)-1, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales all three axes by scale. |
Matrix4f |
translationRotateScaleInvert(Vector3fc translation,
Quaternionfc quat,
Vector3fc scale)
Set
this matrix to (T * R * S)-1, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales the axes by scale. |
Matrix4f |
translationRotateScaleMulAffine(float tx,
float ty,
float tz,
float qx,
float qy,
float qz,
float qw,
float sx,
float sy,
float sz,
Matrix4f m)
Set
this matrix to T * R * S * M, where T is a translation by the given (tx, ty, tz),
R is a rotation - and possibly scaling - transformation specified by the quaternion (qx, qy, qz, qw), S is a scaling transformation
which scales the three axes x, y and z by (sx, sy, sz) and M is an affine matrix. |
Matrix4f |
translationRotateScaleMulAffine(Vector3fc translation,
Quaternionfc quat,
Vector3fc scale,
Matrix4f m)
Set
this matrix to T * R * S * M, where T is the given translation,
R is a rotation - and possibly scaling - transformation specified by the given quaternion, S is a scaling transformation
which scales the axes by scale and M is an affine matrix. |
Matrix4f |
translationRotateTowards(float posX,
float posY,
float posZ,
float dirX,
float dirY,
float dirZ,
float upX,
float upY,
float upZ)
Set this matrix to a model transformation for a right-handed coordinate system,
that translates to the given
(posX, posY, posZ) and aligns the local -z
axis with (dirX, dirY, dirZ). |
Matrix4f |
translationRotateTowards(Vector3fc pos,
Vector3fc dir,
Vector3fc up)
Set this matrix to a model transformation for a right-handed coordinate system,
that translates to the given
pos and aligns the local -z
axis with dir. |
Matrix4f |
transpose()
Transpose this matrix.
|
Matrix4f |
transpose(Matrix4f dest)
Transpose this matrix and store the result in
dest. |
Matrix4f |
transpose3x3()
Transpose only the upper left 3x3 submatrix of this matrix.
|
Matrix3f |
transpose3x3(Matrix3f dest)
Transpose only the upper left 3x3 submatrix of this matrix and store the result in
dest. |
Matrix4f |
transpose3x3(Matrix4f dest)
Transpose only the upper left 3x3 submatrix of this matrix and store the result in
dest. |
Matrix4f |
trapezoidCrop(float p0x,
float p0y,
float p1x,
float p1y,
float p2x,
float p2y,
float p3x,
float p3y)
Set
this matrix to a perspective transformation that maps the trapezoid spanned by the four corner coordinates
(p0x, p0y), (p1x, p1y), (p2x, p2y) and (p3x, p3y) to the unit square [(-1, -1)..(+1, +1)]. |
Vector3f |
unproject(float winX,
float winY,
float winZ,
int[] viewport,
Vector3f dest)
Unproject the given window coordinates
(winX, winY, winZ) by this matrix using the specified viewport. |
Vector4f |
unproject(float winX,
float winY,
float winZ,
int[] viewport,
Vector4f dest)
Unproject the given window coordinates
(winX, winY, winZ) by this matrix using the specified viewport. |
Vector3f |
unproject(Vector3fc winCoords,
int[] viewport,
Vector3f dest)
Unproject the given window coordinates
winCoords by this matrix using the specified viewport. |
Vector4f |
unproject(Vector3fc winCoords,
int[] viewport,
Vector4f dest)
Unproject the given window coordinates
winCoords by this matrix using the specified viewport. |
Vector3f |
unprojectInv(float winX,
float winY,
float winZ,
int[] viewport,
Vector3f dest)
Unproject the given window coordinates
(winX, winY, winZ) by this matrix using the specified viewport. |
Vector4f |
unprojectInv(float winX,
float winY,
float winZ,
int[] viewport,
Vector4f dest)
Unproject the given window coordinates
(winX, winY, winZ) by this matrix using the specified viewport. |
Vector3f |
unprojectInv(Vector3fc winCoords,
int[] viewport,
Vector3f dest)
Unproject the given window coordinates
winCoords by this matrix using the specified viewport. |
Vector4f |
unprojectInv(Vector3fc winCoords,
int[] viewport,
Vector4f dest)
Unproject the given window coordinates
winCoords by this matrix using the specified viewport. |
Matrix4f |
unprojectInvRay(float winX,
float winY,
int[] viewport,
Vector3f originDest,
Vector3f dirDest)
Unproject the given 2D window coordinates
(winX, winY) by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0. |
Matrix4f |
unprojectInvRay(Vector2fc winCoords,
int[] viewport,
Vector3f originDest,
Vector3f dirDest)
Unproject the given window coordinates
winCoords by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0. |
Matrix4f |
unprojectRay(float winX,
float winY,
int[] viewport,
Vector3f originDest,
Vector3f dirDest)
Unproject the given 2D window coordinates
(winX, winY) by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0. |
Matrix4f |
unprojectRay(Vector2fc winCoords,
int[] viewport,
Vector3f originDest,
Vector3f dirDest)
Unproject the given 2D window coordinates
winCoords by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0. |
Matrix4f |
withLookAtUp(float upX,
float upY,
float upZ)
Apply a transformation to this matrix to ensure that the local Y axis (as obtained by
positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by positiveZ(Vector3f)) and the
given vector (upX, upY, upZ). |
Matrix4f |
withLookAtUp(float upX,
float upY,
float upZ,
Matrix4f dest)
Apply a transformation to this matrix to ensure that the local Y axis (as obtained by
Matrix4fc.positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4fc.positiveZ(Vector3f)) and the
given vector (upX, upY, upZ), and store the result in dest. |
Matrix4f |
withLookAtUp(Vector3fc up)
Apply a transformation to this matrix to ensure that the local Y axis (as obtained by
positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by positiveZ(Vector3f)) and the
given vector up. |
Matrix4f |
withLookAtUp(Vector3fc up,
Matrix4f dest)
Apply a transformation to this matrix to ensure that the local Y axis (as obtained by
Matrix4fc.positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4fc.positiveZ(Vector3f)) and the
given vector up, and store the result in dest. |
void |
writeExternal(ObjectOutput out) |
Matrix4f |
zero()
Set all the values within this matrix to
0. |
public Matrix4f()
public Matrix4f(Matrix3fc mat)
Matrix4f by setting its uppper left 3x3 submatrix to the values of the given Matrix3fc
and the rest to identity.mat - the Matrix3fcpublic Matrix4f(Matrix4fc mat)
Matrix4f and make it a copy of the given matrix.mat - the Matrix4fc to copy the values frompublic Matrix4f(Matrix4x3fc mat)
Matrix4f and set its upper 4x3 submatrix to the given matrix mat
and all other elements to identity.mat - the Matrix4x3fc to copy the values frompublic Matrix4f(Matrix4dc mat)
Matrix4f and make it a copy of the given matrix.
Note that due to the given Matrix4dc storing values in double-precision and the constructed Matrix4f storing them
in single-precision, there is the possibility of losing precision.
mat - the Matrix4dc to copy the values frompublic Matrix4f(float m00,
float m01,
float m02,
float m03,
float m10,
float m11,
float m12,
float m13,
float m20,
float m21,
float m22,
float m23,
float m30,
float m31,
float m32,
float m33)
The matrix layout will be:
m00, m10, m20, m30
m01, m11, m21, m31
m02, m12, m22, m32
m03, m13, m23, m33
m00 - the value of m00m01 - the value of m01m02 - the value of m02m03 - the value of m03m10 - the value of m10m11 - the value of m11m12 - the value of m12m13 - the value of m13m20 - the value of m20m21 - the value of m21m22 - the value of m22m23 - the value of m23m30 - the value of m30m31 - the value of m31m32 - the value of m32m33 - the value of m33public Matrix4f(FloatBuffer buffer)
Matrix4f by reading its 16 float components from the given FloatBuffer
at the buffer's current position.
That FloatBuffer is expected to hold the values in column-major order.
The buffer's position will not be changed by this method.
buffer - the FloatBuffer to read the matrix values frompublic Matrix4f assume(int properties)
Use one or multiple of 0, Matrix4fc.PROPERTY_IDENTITY,
Matrix4fc.PROPERTY_TRANSLATION, Matrix4fc.PROPERTY_AFFINE,
Matrix4fc.PROPERTY_PERSPECTIVE, Matrix4fc.PROPERTY_ORTHONORMAL.
properties - bitset of the properties to assume about this matrixpublic Matrix4f determineProperties()
properties() based
on the current matrix element values.public int properties()
Matrix4fcMatrix4fc.PROPERTY_IDENTITY, Matrix4fc.PROPERTY_AFFINE,
Matrix4fc.PROPERTY_TRANSLATION and Matrix4fc.PROPERTY_PERSPECTIVE.properties in interface Matrix4fcpublic float m00()
Matrix4fcpublic float m01()
Matrix4fcpublic float m02()
Matrix4fcpublic float m03()
Matrix4fcpublic float m10()
Matrix4fcpublic float m11()
Matrix4fcpublic float m12()
Matrix4fcpublic float m13()
Matrix4fcpublic float m20()
Matrix4fcpublic float m21()
Matrix4fcpublic float m22()
Matrix4fcpublic float m23()
Matrix4fcpublic float m30()
Matrix4fcpublic float m31()
Matrix4fcpublic float m32()
Matrix4fcpublic float m33()
Matrix4fcpublic Matrix4f m00(float m00)
m00 - the new valuepublic Matrix4f m01(float m01)
m01 - the new valuepublic Matrix4f m02(float m02)
m02 - the new valuepublic Matrix4f m03(float m03)
m03 - the new valuepublic Matrix4f m10(float m10)
m10 - the new valuepublic Matrix4f m11(float m11)
m11 - the new valuepublic Matrix4f m12(float m12)
m12 - the new valuepublic Matrix4f m13(float m13)
m13 - the new valuepublic Matrix4f m20(float m20)
m20 - the new valuepublic Matrix4f m21(float m21)
m21 - the new valuepublic Matrix4f m22(float m22)
m22 - the new valuepublic Matrix4f m23(float m23)
m23 - the new valuepublic Matrix4f m30(float m30)
m30 - the new valuepublic Matrix4f m31(float m31)
m31 - the new valuepublic Matrix4f m32(float m32)
m32 - the new valuepublic Matrix4f m33(float m33)
m33 - the new valuepublic Matrix4f _m00(float m00)
m00 - the new valuepublic Matrix4f _m01(float m01)
m01 - the new valuepublic Matrix4f _m02(float m02)
m02 - the new valuepublic Matrix4f _m03(float m03)
m03 - the new valuepublic Matrix4f _m10(float m10)
m10 - the new valuepublic Matrix4f _m11(float m11)
m11 - the new valuepublic Matrix4f _m12(float m12)
m12 - the new valuepublic Matrix4f _m13(float m13)
m13 - the new valuepublic Matrix4f _m20(float m20)
m20 - the new valuepublic Matrix4f _m21(float m21)
m21 - the new valuepublic Matrix4f _m22(float m22)
m22 - the new valuepublic Matrix4f _m23(float m23)
m23 - the new valuepublic Matrix4f _m30(float m30)
m30 - the new valuepublic Matrix4f _m31(float m31)
m31 - the new valuepublic Matrix4f _m32(float m32)
m32 - the new valuepublic Matrix4f _m33(float m33)
m33 - the new valuepublic Matrix4f identity()
Please note that if a call to identity() is immediately followed by a call to:
translate,
rotate,
scale,
perspective,
frustum,
ortho,
ortho2D,
lookAt,
lookAlong,
or any of their overloads, then the call to identity() can be omitted and the subsequent call replaced with:
translation,
rotation,
scaling,
setPerspective,
setFrustum,
setOrtho,
setOrtho2D,
setLookAt,
setLookAlong,
or any of their overloads.
public Matrix4f set(Matrix4fc m)
m into this matrix.m - the matrix to copy the values fromMatrix4f(Matrix4fc),
get(Matrix4f)public Matrix4f set(Matrix4x3fc m)
m into this matrix
and set the other matrix elements to identity.m - the matrix to copy the values fromMatrix4f(Matrix4x3fc)public Matrix4f set(Matrix4dc m)
m into this matrix.
Note that due to the given matrix m storing values in double-precision and this matrix storing
them in single-precision, there is the possibility to lose precision.
m - the matrix to copy the values fromMatrix4f(Matrix4dc),
get(Matrix4d)public Matrix4f set(Matrix3fc mat)
mat - the Matrix3fcMatrix4f(Matrix3fc)public Matrix4f set(AxisAngle4f axisAngle)
AxisAngle4f.axisAngle - the AxisAngle4fpublic Matrix4f set(AxisAngle4d axisAngle)
AxisAngle4d.axisAngle - the AxisAngle4dpublic Matrix4f set(Quaternionfc q)
Quaternionfc.
This method is equivalent to calling: rotation(q)
Reference: http://www.euclideanspace.com/
q - the Quaternionfcrotation(Quaternionfc)public Matrix4f set(Quaterniondc q)
Quaterniondc.
Reference: http://www.euclideanspace.com/
q - the Quaterniondcpublic Matrix4f set3x3(Matrix4f mat)
Matrix4f to that of the given Matrix4f
and don't change the other elements.mat - the Matrix4fpublic Matrix4f set4x3(Matrix4x3fc mat)
Matrix4f to the given Matrix4x3fc
and don't change the other elements.mat - the Matrix4x3fcMatrix4x3f.get(Matrix4f)public Matrix4f set4x3(Matrix4f mat)
Matrix4f to the upper 4x3 submatrix of the given Matrix4f
and don't change the other elements.mat - the Matrix4fpublic Matrix4f mul(Matrix4fc right)
right matrix and store the result in this.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
right - the right operand of the matrix multiplicationpublic Matrix4f mul(Matrix4fc right, Matrix4f dest)
Matrix4fcright matrix and store the result in dest.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
public Matrix4f mulLocal(Matrix4fc left)
left matrix and store the result in this.
If M is this matrix and L the left matrix,
then the new matrix will be L * M. So when transforming a
vector v with the new matrix by using L * M * v, the
transformation of this matrix will be applied first!
left - the left operand of the matrix multiplicationpublic Matrix4f mulLocal(Matrix4fc left, Matrix4f dest)
Matrix4fcleft matrix and store the result in dest.
If M is this matrix and L the left matrix,
then the new matrix will be L * M. So when transforming a
vector v with the new matrix by using L * M * v, the
transformation of this matrix will be applied first!
public Matrix4f mulLocalAffine(Matrix4fc left)
left matrix, both of which are assumed to be affine, and store the result in this.
This method assumes that this matrix and the given left matrix both represent an affine transformation
(i.e. their last rows are equal to (0, 0, 0, 1))
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).
This method will not modify either the last row of this or the last row of left.
If M is this matrix and L the left matrix,
then the new matrix will be L * M. So when transforming a
vector v with the new matrix by using L * M * v, the
transformation of this matrix will be applied first!
left - the left operand of the matrix multiplication (the last row is assumed to be (0, 0, 0, 1))public Matrix4f mulLocalAffine(Matrix4fc left, Matrix4f dest)
Matrix4fcleft matrix, both of which are assumed to be affine, and store the result in dest.
This method assumes that this matrix and the given left matrix both represent an affine transformation
(i.e. their last rows are equal to (0, 0, 0, 1))
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).
This method will not modify either the last row of this or the last row of left.
If M is this matrix and L the left matrix,
then the new matrix will be L * M. So when transforming a
vector v with the new matrix by using L * M * v, the
transformation of this matrix will be applied first!
mulLocalAffine in interface Matrix4fcleft - the left operand of the matrix multiplication (the last row is assumed to be (0, 0, 0, 1))dest - the destination matrix, which will hold the resultpublic Matrix4f mul(Matrix4x3fc right)
right matrix and store the result in this.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
right - the right operand of the matrix multiplicationpublic Matrix4f mul(Matrix4x3fc right, Matrix4f dest)
Matrix4fcright matrix and store the result in dest.
The last row of the right matrix is assumed to be (0, 0, 0, 1).
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
public Matrix4f mul(Matrix3x2fc right)
right matrix and store the result in this.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
right - the right operand of the matrix multiplicationpublic Matrix4f mul(Matrix3x2fc right, Matrix4f dest)
Matrix4fcright matrix and store the result in dest.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
public Matrix4f mulPerspectiveAffine(Matrix4fc view)
this symmetric perspective projection matrix by the supplied affine view matrix.
If P is this matrix and V the view matrix,
then the new matrix will be P * V. So when transforming a
vector v with the new matrix by using P * V * v, the
transformation of the view matrix will be applied first!
view - the affine matrix to multiply this symmetric perspective projection matrix bypublic Matrix4f mulPerspectiveAffine(Matrix4fc view, Matrix4f dest)
Matrix4fcthis symmetric perspective projection matrix by the supplied affine view matrix and store the result in dest.
If P is this matrix and V the view matrix,
then the new matrix will be P * V. So when transforming a
vector v with the new matrix by using P * V * v, the
transformation of the view matrix will be applied first!
mulPerspectiveAffine in interface Matrix4fcview - the affine matrix to multiply this symmetric perspective projection matrix bydest - the destination matrix, which will hold the resultpublic Matrix4f mulPerspectiveAffine(Matrix4x3fc view)
this symmetric perspective projection matrix by the supplied view matrix.
If P is this matrix and V the view matrix,
then the new matrix will be P * V. So when transforming a
vector v with the new matrix by using P * V * v, the
transformation of the view matrix will be applied first!
view - the matrix to multiply this symmetric perspective projection matrix bypublic Matrix4f mulPerspectiveAffine(Matrix4x3fc view, Matrix4f dest)
Matrix4fcthis symmetric perspective projection matrix by the supplied view matrix and store the result in dest.
If P is this matrix and V the view matrix,
then the new matrix will be P * V. So when transforming a
vector v with the new matrix by using P * V * v, the
transformation of the view matrix will be applied first!
mulPerspectiveAffine in interface Matrix4fcview - the matrix to multiply this symmetric perspective projection matrix bydest - the destination matrix, which will hold the resultpublic Matrix4f mulAffineR(Matrix4fc right)
right matrix, which is assumed to be affine, and store the result in this.
This method assumes that the given right matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
right - the right operand of the matrix multiplication (the last row is assumed to be (0, 0, 0, 1))public Matrix4f mulAffineR(Matrix4fc right, Matrix4f dest)
Matrix4fcright matrix, which is assumed to be affine, and store the result in dest.
This method assumes that the given right matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
mulAffineR in interface Matrix4fcright - the right operand of the matrix multiplication (the last row is assumed to be (0, 0, 0, 1))dest - the destination matrix, which will hold the resultpublic Matrix4f mulAffine(Matrix4fc right)
right matrix, both of which are assumed to be affine, and store the result in this.
This method assumes that this matrix and the given right matrix both represent an affine transformation
(i.e. their last rows are equal to (0, 0, 0, 1))
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).
This method will not modify either the last row of this or the last row of right.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
right - the right operand of the matrix multiplication (the last row is assumed to be (0, 0, 0, 1))public Matrix4f mulAffine(Matrix4fc right, Matrix4f dest)
Matrix4fcright matrix, both of which are assumed to be affine, and store the result in dest.
This method assumes that this matrix and the given right matrix both represent an affine transformation
(i.e. their last rows are equal to (0, 0, 0, 1))
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).
This method will not modify either the last row of this or the last row of right.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
public Matrix4f mulTranslationAffine(Matrix4fc right, Matrix4f dest)
Matrix4fcright matrix, which is assumed to be affine, and store the result in dest.
This method assumes that this matrix only contains a translation, and that the given right matrix represents an affine transformation
(i.e. its last row is equal to (0, 0, 0, 1)).
This method will not modify either the last row of this or the last row of right.
If M is this matrix and R the right matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
transformation of the right matrix will be applied first!
mulTranslationAffine in interface Matrix4fcright - the right operand of the matrix multiplication (the last row is assumed to be (0, 0, 0, 1))dest - the destination matrix, which will hold the resultpublic Matrix4f mulOrthoAffine(Matrix4fc view)
this orthographic projection matrix by the supplied affine view matrix.
If M is this matrix and V the view matrix,
then the new matrix will be M * V. So when transforming a
vector v with the new matrix by using M * V * v, the
transformation of the view matrix will be applied first!
view - the affine matrix which to multiply this withpublic Matrix4f mulOrthoAffine(Matrix4fc view, Matrix4f dest)
Matrix4fcthis orthographic projection matrix by the supplied affine view matrix
and store the result in dest.
If M is this matrix and V the view matrix,
then the new matrix will be M * V. So when transforming a
vector v with the new matrix by using M * V * v, the
transformation of the view matrix will be applied first!
mulOrthoAffine in interface Matrix4fcview - the affine matrix which to multiply this withdest - the destination matrix, which will hold the resultpublic Matrix4f fma4x3(Matrix4fc other, float otherFactor)
this and other
by first multiplying each component of other's 4x3 submatrix by otherFactor and
adding that result to this.
The matrix other will not be changed.
other - the other matrixotherFactor - the factor to multiply each of the other matrix's 4x3 componentspublic Matrix4f fma4x3(Matrix4fc other, float otherFactor, Matrix4f dest)
Matrix4fcthis and other
by first multiplying each component of other's 4x3 submatrix by otherFactor,
adding that to this and storing the final result in dest.
The other components of dest will be set to the ones of this.
The matrices this and other will not be changed.
public Matrix4f add(Matrix4fc other)
this and other.other - the other addendpublic Matrix4f add(Matrix4fc other, Matrix4f dest)
Matrix4fcthis and other and store the result in dest.public Matrix4f sub(Matrix4fc subtrahend)
subtrahend from this.subtrahend - the subtrahendpublic Matrix4f sub(Matrix4fc subtrahend, Matrix4f dest)
Matrix4fcsubtrahend from this and store the result in dest.public Matrix4f mulComponentWise(Matrix4fc other)
this by other.other - the other matrixpublic Matrix4f mulComponentWise(Matrix4fc other, Matrix4f dest)
Matrix4fcthis by other and store the result in dest.mulComponentWise in interface Matrix4fcother - the other matrixdest - will hold the resultpublic Matrix4f add4x3(Matrix4fc other)
this and other.other - the other addendpublic Matrix4f add4x3(Matrix4fc other, Matrix4f dest)
Matrix4fcthis and other
and store the result in dest.
The other components of dest will be set to the ones of this.
public Matrix4f sub4x3(Matrix4f subtrahend)
subtrahend from this.subtrahend - the subtrahendpublic Matrix4f sub4x3(Matrix4fc subtrahend, Matrix4f dest)
Matrix4fcsubtrahend from this
and store the result in dest.
The other components of dest will be set to the ones of this.
public Matrix4f mul4x3ComponentWise(Matrix4fc other)
this by other.other - the other matrixpublic Matrix4f mul4x3ComponentWise(Matrix4fc other, Matrix4f dest)
Matrix4fcthis by other
and store the result in dest.
The other components of dest will be set to the ones of this.
mul4x3ComponentWise in interface Matrix4fcother - the other matrixdest - will hold the resultpublic Matrix4f set(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33)
m00 - the new value of m00m01 - the new value of m01m02 - the new value of m02m03 - the new value of m03m10 - the new value of m10m11 - the new value of m11m12 - the new value of m12m13 - the new value of m13m20 - the new value of m20m21 - the new value of m21m22 - the new value of m22m23 - the new value of m23m30 - the new value of m30m31 - the new value of m31m32 - the new value of m32m33 - the new value of m33public Matrix4f set(float[] m, int off)
The results will look like this:
0, 4, 8, 12
1, 5, 9, 13
2, 6, 10, 14
3, 7, 11, 15
m - the array to read the matrix values fromoff - the offset into the arrayset(float[])public Matrix4f set(float[] m)
The results will look like this:
0, 4, 8, 12
1, 5, 9, 13
2, 6, 10, 14
3, 7, 11, 15
m - the array to read the matrix values fromset(float[], int)public Matrix4f set(FloatBuffer buffer)
FloatBuffer in column-major order,
starting at its current position.
The FloatBuffer is expected to contain the values in column-major order.
The position of the FloatBuffer will not be changed by this method.
buffer - the FloatBuffer to read the matrix values from in column-major orderpublic Matrix4f set(ByteBuffer buffer)
ByteBuffer in column-major order,
starting at its current position.
The ByteBuffer is expected to contain the values in column-major order.
The position of the ByteBuffer will not be changed by this method.
buffer - the ByteBuffer to read the matrix values from in column-major orderpublic Matrix4f set(Vector4fc col0, Vector4fc col1, Vector4fc col2, Vector4fc col3)
col0 - the first columncol1 - the second columncol2 - the third columncol3 - the fourth columnpublic float determinant()
Matrix4fc
If this matrix represents an affine transformation, such as translation, rotation, scaling and shearing,
and thus its last row is equal to (0, 0, 0, 1), then Matrix4fc.determinantAffine() can be used instead of this method.
determinant in interface Matrix4fcMatrix4fc.determinantAffine()public float determinant3x3()
Matrix4fcdeterminant3x3 in interface Matrix4fcpublic float determinantAffine()
Matrix4fcaffine transformation and thus
its last row is equal to (0, 0, 0, 1).determinantAffine in interface Matrix4fcpublic Matrix4f invert(Matrix4f dest)
Matrix4fcdest.
If this matrix represents an affine transformation, such as translation, rotation, scaling and shearing,
and thus its last row is equal to (0, 0, 0, 1), then Matrix4fc.invertAffine(Matrix4f) can be used instead of this method.
invert in interface Matrix4fcdest - will hold the resultMatrix4fc.invertAffine(Matrix4f)public Matrix4f invert()
If this matrix represents an affine transformation, such as translation, rotation, scaling and shearing,
and thus its last row is equal to (0, 0, 0, 1), then invertAffine() can be used instead of this method.
invertAffine()public Matrix4f invertPerspective(Matrix4f dest)
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation,
then this method builds the inverse of this and stores it into the given dest.
This method can be used to quickly obtain the inverse of a perspective projection matrix when being obtained via perspective().
invertPerspective in interface Matrix4fcdest - will hold the inverse of thisperspective(float, float, float, float)public Matrix4f invertPerspective()
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation,
then this method builds the inverse of this.
This method can be used to quickly obtain the inverse of a perspective projection matrix when being obtained via perspective().
perspective(float, float, float, float)public Matrix4f invertFrustum(Matrix4f dest)
this is an arbitrary perspective projection matrix obtained via one of the frustum() methods
or via setFrustum(),
then this method builds the inverse of this and stores it into the given dest.
This method can be used to quickly obtain the inverse of a perspective projection matrix.
If this matrix represents a symmetric perspective frustum transformation, as obtained via perspective(), then
invertPerspective(Matrix4f) should be used instead.
invertFrustum in interface Matrix4fcdest - will hold the inverse of thisfrustum(float, float, float, float, float, float),
invertPerspective(Matrix4f)public Matrix4f invertFrustum()
this is an arbitrary perspective projection matrix obtained via one of the frustum() methods
or via setFrustum(),
then this method builds the inverse of this.
This method can be used to quickly obtain the inverse of a perspective projection matrix.
If this matrix represents a symmetric perspective frustum transformation, as obtained via perspective(), then
invertPerspective() should be used instead.
frustum(float, float, float, float, float, float),
invertPerspective()public Matrix4f invertOrtho(Matrix4f dest)
Matrix4fcthis orthographic projection matrix and store the result into the given dest.
This method can be used to quickly obtain the inverse of an orthographic projection matrix.
invertOrtho in interface Matrix4fcdest - will hold the inverse of thispublic Matrix4f invertOrtho()
this orthographic projection matrix.
This method can be used to quickly obtain the inverse of an orthographic projection matrix.
public Matrix4f invertPerspectiveView(Matrix4fc view, Matrix4f dest)
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation
and the given view matrix is affine and has unit scaling (for example by being obtained via lookAt()),
then this method builds the inverse of this * view and stores it into the given dest.
This method can be used to quickly obtain the inverse of the combination of the view and projection matrices, when both were obtained
via the common methods perspective() and lookAt() or
other methods, that build affine matrices, such as translate and rotate(float, float, float, float), except for scale().
For the special cases of the matrices this and view mentioned above, this method is equivalent to the following code:
dest.set(this).mul(view).invert();
invertPerspectiveView in interface Matrix4fcview - the view transformation (must be affine and have unit scaling)dest - will hold the inverse of this * viewpublic Matrix4f invertPerspectiveView(Matrix4x3fc view, Matrix4f dest)
this is a perspective projection matrix obtained via one of the perspective() methods
or via setPerspective(), that is, if this is a symmetrical perspective frustum transformation
and the given view matrix has unit scaling,
then this method builds the inverse of this * view and stores it into the given dest.
This method can be used to quickly obtain the inverse of the combination of the view and projection matrices, when both were obtained
via the common methods perspective() and lookAt() or
other methods, that build affine matrices, such as translate and rotate(float, float, float, float), except for scale().
For the special cases of the matrices this and view mentioned above, this method is equivalent to the following code:
dest.set(this).mul(view).invert();
invertPerspectiveView in interface Matrix4fcview - the view transformation (must have unit scaling)dest - will hold the inverse of this * viewpublic Matrix4f invertAffine(Matrix4f dest)
Matrix4fcaffine transformation (i.e. its last row is equal to (0, 0, 0, 1))
and write the result into dest.invertAffine in interface Matrix4fcdest - will hold the resultpublic Matrix4f invertAffine()
affine transformation (i.e. its last row is equal to (0, 0, 0, 1)).public Matrix4f transpose(Matrix4f dest)
Matrix4fcdest.public Matrix4f transpose3x3()
All other matrix elements are left unchanged.
public Matrix4f transpose3x3(Matrix4f dest)
Matrix4fcdest.
All other matrix elements are left unchanged.
transpose3x3 in interface Matrix4fcdest - will hold the resultpublic Matrix3f transpose3x3(Matrix3f dest)
Matrix4fcdest.transpose3x3 in interface Matrix4fcdest - will hold the resultpublic Matrix4f transpose()
public Matrix4f translation(float x, float y, float z)
The resulting matrix can be multiplied against another transformation matrix to obtain an additional translation.
In order to post-multiply a translation transformation directly to a
matrix, use translate() instead.
x - the offset to translate in xy - the offset to translate in yz - the offset to translate in ztranslate(float, float, float)public Matrix4f translation(Vector3fc offset)
The resulting matrix can be multiplied against another transformation matrix to obtain an additional translation.
In order to post-multiply a translation transformation directly to a
matrix, use translate() instead.
offset - the offsets in x, y and z to translatetranslate(float, float, float)public Matrix4f setTranslation(float x, float y, float z)
(m30, m31, m32) of this matrix to the given values (x, y, z).
Note that this will only work properly for orthogonal matrices (without any perspective).
To build a translation matrix instead, use translation(float, float, float).
To apply a translation, use translate(float, float, float).
x - the offset to translate in xy - the offset to translate in yz - the offset to translate in ztranslation(float, float, float),
translate(float, float, float)public Matrix4f setTranslation(Vector3fc xyz)
(m30, m31, m32) of this matrix to the values (xyz.x, xyz.y, xyz.z).
Note that this will only work properly for orthogonal matrices (without any perspective).
To build a translation matrix instead, use translation(Vector3fc).
To apply a translation, use translate(Vector3fc).
xyz - the units to translate in (x, y, z)translation(Vector3fc),
translate(Vector3fc)public Vector3f getTranslation(Vector3f dest)
Matrix4fc(m30, m31, m32) of this matrix and store them in the given vector xyz.getTranslation in interface Matrix4fcdest - will hold the translation components of this matrixpublic Vector3f getScale(Vector3f dest)
Matrix4fcthis matrix for the three base axes.public String toString()
This method creates a new DecimalFormat on every invocation with the format string "0.000E0;-".
public String toString(NumberFormat formatter)
NumberFormat.formatter - the NumberFormat used to format the matrix values withpublic Matrix4f get(Matrix4f dest)
this matrix and store them into
dest.
This is the reverse method of set(Matrix4fc) and allows to obtain
intermediate calculation results when chaining multiple transformations.
get in interface Matrix4fcdest - the destination matrixset(Matrix4fc)public Matrix4x3f get4x3(Matrix4x3f dest)
Matrix4fcthis matrix and store them into
dest.get4x3 in interface Matrix4fcdest - the destination matrixMatrix4x3f.set(Matrix4fc)public Matrix4d get(Matrix4d dest)
this matrix and store them into
dest.
This is the reverse method of set(Matrix4dc) and allows to obtain
intermediate calculation results when chaining multiple transformations.
get in interface Matrix4fcdest - the destination matrixset(Matrix4dc)public Matrix3f get3x3(Matrix3f dest)
Matrix4fcthis matrix and store them into
dest.get3x3 in interface Matrix4fcdest - the destination matrixMatrix3f.set(Matrix4fc)public Matrix3d get3x3(Matrix3d dest)
Matrix4fcthis matrix and store them into
dest.get3x3 in interface Matrix4fcdest - the destination matrixMatrix3d.set(Matrix4fc)public AxisAngle4f getRotation(AxisAngle4f dest)
Matrix4fcthis matrix and store the represented rotation
into the given AxisAngle4f.getRotation in interface Matrix4fcdest - the destination AxisAngle4fAxisAngle4f.set(Matrix4fc)public AxisAngle4d getRotation(AxisAngle4d dest)
Matrix4fcthis matrix and store the represented rotation
into the given AxisAngle4d.getRotation in interface Matrix4fcdest - the destination AxisAngle4dAxisAngle4f.set(Matrix4fc)public Quaternionf getUnnormalizedRotation(Quaternionf dest)
Matrix4fcthis matrix and store the represented rotation
into the given Quaternionf.
This method assumes that the first three column vectors of the upper left 3x3 submatrix are not normalized and thus allows to ignore any additional scaling factor that is applied to the matrix.
getUnnormalizedRotation in interface Matrix4fcdest - the destination QuaternionfQuaternionf.setFromUnnormalized(Matrix4fc)public Quaternionf getNormalizedRotation(Quaternionf dest)
Matrix4fcthis matrix and store the represented rotation
into the given Quaternionf.
This method assumes that the first three column vectors of the upper left 3x3 submatrix are normalized.
getNormalizedRotation in interface Matrix4fcdest - the destination QuaternionfQuaternionf.setFromNormalized(Matrix4fc)public Quaterniond getUnnormalizedRotation(Quaterniond dest)
Matrix4fcthis matrix and store the represented rotation
into the given Quaterniond.
This method assumes that the first three column vectors of the upper left 3x3 submatrix are not normalized and thus allows to ignore any additional scaling factor that is applied to the matrix.
getUnnormalizedRotation in interface Matrix4fcdest - the destination QuaterniondQuaterniond.setFromUnnormalized(Matrix4fc)public Quaterniond getNormalizedRotation(Quaterniond dest)
Matrix4fcthis matrix and store the represented rotation
into the given Quaterniond.
This method assumes that the first three column vectors of the upper left 3x3 submatrix are normalized.
getNormalizedRotation in interface Matrix4fcdest - the destination QuaterniondQuaterniond.setFromNormalized(Matrix4fc)public FloatBuffer get(FloatBuffer buffer)
Matrix4fcFloatBuffer at the current
buffer position.
This method will not increment the position of the given FloatBuffer.
In order to specify the offset into the FloatBuffer at which
the matrix is stored, use Matrix4fc.get(int, FloatBuffer), taking
the absolute position as parameter.
get in interface Matrix4fcbuffer - will receive the values of this matrix in column-major order at its current positionMatrix4fc.get(int, FloatBuffer)public FloatBuffer get(int index, FloatBuffer buffer)
Matrix4fcFloatBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given FloatBuffer.
public ByteBuffer get(ByteBuffer buffer)
Matrix4fcByteBuffer at the current
buffer position.
This method will not increment the position of the given ByteBuffer.
In order to specify the offset into the ByteBuffer at which
the matrix is stored, use Matrix4fc.get(int, ByteBuffer), taking
the absolute position as parameter.
get in interface Matrix4fcbuffer - will receive the values of this matrix in column-major order at its current positionMatrix4fc.get(int, ByteBuffer)public ByteBuffer get(int index, ByteBuffer buffer)
Matrix4fcByteBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given ByteBuffer.
public FloatBuffer get4x3(FloatBuffer buffer)
Matrix4fcFloatBuffer at the current
buffer position.
This method will not increment the position of the given FloatBuffer.
In order to specify the offset into the FloatBuffer at which
the matrix is stored, use Matrix4fc.get(int, FloatBuffer), taking
the absolute position as parameter.
get4x3 in interface Matrix4fcbuffer - will receive the values of the upper 4x3 submatrix in column-major order at its current positionMatrix4fc.get(int, FloatBuffer)public FloatBuffer get4x3(int index, FloatBuffer buffer)
Matrix4fcFloatBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given FloatBuffer.
public ByteBuffer get4x3(ByteBuffer buffer)
Matrix4fcByteBuffer at the current
buffer position.
This method will not increment the position of the given ByteBuffer.
In order to specify the offset into the ByteBuffer at which
the matrix is stored, use Matrix4fc.get(int, ByteBuffer), taking
the absolute position as parameter.
get4x3 in interface Matrix4fcbuffer - will receive the values of the upper 4x3 submatrix in column-major order at its current positionMatrix4fc.get(int, ByteBuffer)public ByteBuffer get4x3(int index, ByteBuffer buffer)
Matrix4fcByteBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given ByteBuffer.
public FloatBuffer getTransposed(FloatBuffer buffer)
Matrix4fcFloatBuffer at the current
buffer position.
This method will not increment the position of the given FloatBuffer.
In order to specify the offset into the FloatBuffer at which
the matrix is stored, use Matrix4fc.getTransposed(int, FloatBuffer), taking
the absolute position as parameter.
getTransposed in interface Matrix4fcbuffer - will receive the values of this matrix in column-major order at its current positionMatrix4fc.getTransposed(int, FloatBuffer)public FloatBuffer getTransposed(int index, FloatBuffer buffer)
Matrix4fcFloatBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given FloatBuffer.
getTransposed in interface Matrix4fcindex - the absolute position into the FloatBufferbuffer - will receive the values of this matrix in column-major orderpublic ByteBuffer getTransposed(ByteBuffer buffer)
Matrix4fcByteBuffer at the current
buffer position.
This method will not increment the position of the given ByteBuffer.
In order to specify the offset into the ByteBuffer at which
the matrix is stored, use Matrix4fc.getTransposed(int, ByteBuffer), taking
the absolute position as parameter.
getTransposed in interface Matrix4fcbuffer - will receive the values of this matrix in column-major order at its current positionMatrix4fc.getTransposed(int, ByteBuffer)public ByteBuffer getTransposed(int index, ByteBuffer buffer)
Matrix4fcByteBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given ByteBuffer.
getTransposed in interface Matrix4fcindex - the absolute position into the ByteBufferbuffer - will receive the values of this matrix in column-major orderpublic FloatBuffer get4x3Transposed(FloatBuffer buffer)
Matrix4fcthis matrix in row-major order into the supplied FloatBuffer at the current
buffer position.
This method will not increment the position of the given FloatBuffer.
In order to specify the offset into the FloatBuffer at which
the matrix is stored, use Matrix4fc.get4x3Transposed(int, FloatBuffer), taking
the absolute position as parameter.
get4x3Transposed in interface Matrix4fcbuffer - will receive the values of the upper 4x3 submatrix in row-major order at its current positionMatrix4fc.get4x3Transposed(int, FloatBuffer)public FloatBuffer get4x3Transposed(int index, FloatBuffer buffer)
Matrix4fcthis matrix in row-major order into the supplied FloatBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given FloatBuffer.
get4x3Transposed in interface Matrix4fcindex - the absolute position into the FloatBufferbuffer - will receive the values of the upper 4x3 submatrix in row-major orderpublic ByteBuffer get4x3Transposed(ByteBuffer buffer)
Matrix4fcthis matrix in row-major order into the supplied ByteBuffer at the current
buffer position.
This method will not increment the position of the given ByteBuffer.
In order to specify the offset into the ByteBuffer at which
the matrix is stored, use Matrix4fc.get4x3Transposed(int, ByteBuffer), taking
the absolute position as parameter.
get4x3Transposed in interface Matrix4fcbuffer - will receive the values of the upper 4x3 submatrix in row-major order at its current positionMatrix4fc.get4x3Transposed(int, ByteBuffer)public ByteBuffer get4x3Transposed(int index, ByteBuffer buffer)
Matrix4fcthis matrix in row-major order into the supplied ByteBuffer starting at the specified
absolute buffer position/index.
This method will not increment the position of the given ByteBuffer.
get4x3Transposed in interface Matrix4fcindex - the absolute position into the ByteBufferbuffer - will receive the values of the upper 4x3 submatrix in row-major orderpublic float[] get(float[] arr,
int offset)
Matrix4fcpublic float[] get(float[] arr)
Matrix4fc
In order to specify an explicit offset into the array, use the method Matrix4fc.get(float[], int).
get in interface Matrix4fcarr - the array to write the matrix values intoMatrix4fc.get(float[], int)public Matrix4f zero()
0.public Matrix4f scaling(float factor)
The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling.
In order to post-multiply a scaling transformation directly to a
matrix, use scale() instead.
factor - the scale factor in x, y and zscale(float)public Matrix4f scaling(float x, float y, float z)
The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling.
In order to post-multiply a scaling transformation directly to a
matrix, use scale() instead.
x - the scale in xy - the scale in yz - the scale in zscale(float, float, float)public Matrix4f scaling(Vector3fc xyz)
xyz.x, xyz.y and xyz.z respectively.
The resulting matrix can be multiplied against another transformation matrix to obtain an additional scaling.
In order to post-multiply a scaling transformation directly to a
matrix use scale() instead.
xyz - the scale in x, y and z respectivelyscale(Vector3fc)public Matrix4f rotation(float angle, Vector3fc axis)
The axis described by the axis vector needs to be a unit vector.
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.
The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.
In order to post-multiply a rotation transformation directly to a
matrix, use rotate() instead.
angle - the angle in radiansaxis - the axis to rotate about (needs to be normalized)rotate(float, Vector3fc)public Matrix4f rotation(AxisAngle4f axisAngle)
AxisAngle4f.
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.
The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.
In order to apply the rotation transformation to an existing transformation,
use rotate() instead.
Reference: http://en.wikipedia.org
axisAngle - the AxisAngle4f (needs to be normalized)rotate(AxisAngle4f)public Matrix4f rotation(float angle, float x, float y, float z)
The axis described by the three components needs to be a unit vector.
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.
The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.
In order to apply the rotation transformation to an existing transformation,
use rotate() instead.
Reference: http://en.wikipedia.org
angle - the angle in radiansx - the x-component of the rotation axisy - the y-component of the rotation axisz - the z-component of the rotation axisrotate(float, float, float, float)public Matrix4f rotationX(float ang)
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.
Reference: http://en.wikipedia.org
ang - the angle in radianspublic Matrix4f rotationY(float ang)
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.
Reference: http://en.wikipedia.org
ang - the angle in radianspublic Matrix4f rotationZ(float ang)
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.
Reference: http://en.wikipedia.org
ang - the angle in radianspublic Matrix4f rotationTowardsXY(float dirX, float dirY)
+X towards (dirX, dirY).
The vector (dirX, dirY) must be a unit vector.
dirX - the x component of the normalized directiondirY - the y component of the normalized directionpublic Matrix4f rotationXYZ(float angleX, float angleY, float angleZ)
angleX radians about the X axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis.
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.
This method is equivalent to calling: rotationX(angleX).rotateY(angleY).rotateZ(angleZ)
angleX - the angle to rotate about XangleY - the angle to rotate about YangleZ - the angle to rotate about Zpublic Matrix4f rotationZYX(float angleZ, float angleY, float angleX)
angleZ radians about the Z axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis.
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.
This method is equivalent to calling: rotationZ(angleZ).rotateY(angleY).rotateX(angleX)
angleZ - the angle to rotate about ZangleY - the angle to rotate about YangleX - the angle to rotate about Xpublic Matrix4f rotationYXZ(float angleY, float angleX, float angleZ)
angleY radians about the Y axis, followed by a rotation
of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis.
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.
This method is equivalent to calling: rotationY(angleY).rotateX(angleX).rotateZ(angleZ)
angleY - the angle to rotate about YangleX - the angle to rotate about XangleZ - the angle to rotate about Zpublic Matrix4f setRotationXYZ(float angleX, float angleY, float angleZ)
angleX radians about the X axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis.
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.
angleX - the angle to rotate about XangleY - the angle to rotate about YangleZ - the angle to rotate about Zpublic Matrix4f setRotationZYX(float angleZ, float angleY, float angleX)
angleZ radians about the Z axis, followed by a rotation
of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis.
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.
angleZ - the angle to rotate about ZangleY - the angle to rotate about YangleX - the angle to rotate about Xpublic Matrix4f setRotationYXZ(float angleY, float angleX, float angleZ)
angleY radians about the Y axis, followed by a rotation
of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis.
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.
angleY - the angle to rotate about YangleX - the angle to rotate about XangleZ - the angle to rotate about Zpublic Matrix4f rotation(Quaternionfc quat)
Quaternionfc.
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.
The resulting matrix can be multiplied against another transformation matrix to obtain an additional rotation.
In order to apply the rotation transformation to an existing transformation,
use rotate() instead.
Reference: http://en.wikipedia.org
quat - the Quaternionfcrotate(Quaternionfc)public Matrix4f translationRotateScale(float tx, float ty, float tz, float qx, float qy, float qz, float qw, float sx, float sy, float sz)
this matrix to T * R * S, where T is a translation by the given (tx, ty, tz),
R is a rotation transformation specified by the quaternion (qx, qy, qz, qw), and S is a scaling transformation
which scales the three axes x, y and z by (sx, sy, sz).
When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation.
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.
This method is equivalent to calling: translation(tx, ty, tz).rotate(quat).scale(sx, sy, sz)
tx - the number of units by which to translate the x-componentty - the number of units by which to translate the y-componenttz - the number of units by which to translate the z-componentqx - the x-coordinate of the vector part of the quaternionqy - the y-coordinate of the vector part of the quaternionqz - the z-coordinate of the vector part of the quaternionqw - the scalar part of the quaternionsx - the scaling factor for the x-axissy - the scaling factor for the y-axissz - the scaling factor for the z-axistranslation(float, float, float),
rotate(Quaternionfc),
scale(float, float, float)public Matrix4f translationRotateScale(Vector3fc translation, Quaternionfc quat, Vector3fc scale)
this matrix to T * R * S, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales the axes by scale.
When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation.
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.
This method is equivalent to calling: translation(translation).rotate(quat).scale(scale)
translation - the translationquat - the quaternion representing a rotationscale - the scaling factorstranslation(Vector3fc),
rotate(Quaternionfc),
scale(Vector3fc)public Matrix4f translationRotateScale(float tx, float ty, float tz, float qx, float qy, float qz, float qw, float scale)
this matrix to T * R * S, where T is a translation by the given (tx, ty, tz),
R is a rotation transformation specified by the quaternion (qx, qy, qz, qw), and S is a scaling transformation
which scales all three axes by scale.
When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation.
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.
This method is equivalent to calling: translation(tx, ty, tz).rotate(quat).scale(scale)
tx - the number of units by which to translate the x-componentty - the number of units by which to translate the y-componenttz - the number of units by which to translate the z-componentqx - the x-coordinate of the vector part of the quaternionqy - the y-coordinate of the vector part of the quaternionqz - the z-coordinate of the vector part of the quaternionqw - the scalar part of the quaternionscale - the scaling factor for all three axestranslation(float, float, float),
rotate(Quaternionfc),
scale(float)public Matrix4f translationRotateScale(Vector3fc translation, Quaternionfc quat, float scale)
this matrix to T * R * S, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales all three axes by scale.
When transforming a vector by the resulting matrix the scaling transformation will be applied first, then the rotation and at last the translation.
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.
This method is equivalent to calling: translation(translation).rotate(quat).scale(scale)
translation - the translationquat - the quaternion representing a rotationscale - the scaling factorstranslation(Vector3fc),
rotate(Quaternionfc),
scale(float)public Matrix4f translationRotateScaleInvert(float tx, float ty, float tz, float qx, float qy, float qz, float qw, float sx, float sy, float sz)
this matrix to (T * R * S)-1, where T is a translation by the given (tx, ty, tz),
R is a rotation transformation specified by the quaternion (qx, qy, qz, qw), and S is a scaling transformation
which scales the three axes x, y and z by (sx, sy, sz).
This method is equivalent to calling: translationRotateScale(...).invert()
tx - the number of units by which to translate the x-componentty - the number of units by which to translate the y-componenttz - the number of units by which to translate the z-componentqx - the x-coordinate of the vector part of the quaternionqy - the y-coordinate of the vector part of the quaternionqz - the z-coordinate of the vector part of the quaternionqw - the scalar part of the quaternionsx - the scaling factor for the x-axissy - the scaling factor for the y-axissz - the scaling factor for the z-axistranslationRotateScale(float, float, float, float, float, float, float, float, float, float),
invert()public Matrix4f translationRotateScaleInvert(Vector3fc translation, Quaternionfc quat, Vector3fc scale)
this matrix to (T * R * S)-1, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales the axes by scale.
This method is equivalent to calling: translationRotateScale(...).invert()
translation - the translationquat - the quaternion representing a rotationscale - the scaling factorstranslationRotateScale(Vector3fc, Quaternionfc, Vector3fc),
invert()public Matrix4f translationRotateScaleInvert(Vector3fc translation, Quaternionfc quat, float scale)
this matrix to (T * R * S)-1, where T is the given translation,
R is a rotation transformation specified by the given quaternion, and S is a scaling transformation
which scales all three axes by scale.
This method is equivalent to calling: translationRotateScale(...).invert()
translation - the translationquat - the quaternion representing a rotationscale - the scaling factorstranslationRotateScale(Vector3fc, Quaternionfc, float),
invert()public Matrix4f translationRotateScaleMulAffine(float tx, float ty, float tz, float qx, float qy, float qz, float qw, float sx, float sy, float sz, Matrix4f m)
this matrix to T * R * S * M, where T is a translation by the given (tx, ty, tz),
R is a rotation - and possibly scaling - transformation specified by the quaternion (qx, qy, qz, qw), S is a scaling transformation
which scales the three axes x, y and z by (sx, sy, sz) and M is an affine matrix.
When transforming a vector by the resulting matrix the transformation described by M will be applied first, then the scaling, then rotation and
at last the translation.
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.
This method is equivalent to calling: translation(tx, ty, tz).rotate(quat).scale(sx, sy, sz).mulAffine(m)
tx - the number of units by which to translate the x-componentty - the number of units by which to translate the y-componenttz - the number of units by which to translate the z-componentqx - the x-coordinate of the vector part of the quaternionqy - the y-coordinate of the vector part of the quaternionqz - the z-coordinate of the vector part of the quaternionqw - the scalar part of the quaternionsx - the scaling factor for the x-axissy - the scaling factor for the y-axissz - the scaling factor for the z-axism - the affine matrix to multiply bytranslation(float, float, float),
rotate(Quaternionfc),
scale(float, float, float),
mulAffine(Matrix4fc)public Matrix4f translationRotateScaleMulAffine(Vector3fc translation, Quaternionfc quat, Vector3fc scale, Matrix4f m)
this matrix to T * R * S * M, where T is the given translation,
R is a rotation - and possibly scaling - transformation specified by the given quaternion, S is a scaling transformation
which scales the axes by scale and M is an affine matrix.
When transforming a vector by the resulting matrix the transformation described by M will be applied first, then the scaling, then rotation and
at last the translation.
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.
This method is equivalent to calling: translation(translation).rotate(quat).scale(scale).mulAffine(m)
translation - the translationquat - the quaternion representing a rotationscale - the scaling factorsm - the affine matrix to multiply bytranslation(Vector3fc),
rotate(Quaternionfc),
mulAffine(Matrix4fc)public Matrix4f translationRotate(float tx, float ty, float tz, float qx, float qy, float qz, float qw)
this matrix to T * R, where T is a translation by the given (tx, ty, tz) and
R is a rotation - and possibly scaling - transformation specified by the quaternion (qx, qy, qz, qw).
When transforming a vector by the resulting matrix the rotation - and possibly scaling - transformation will be applied first and then the translation.
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.
This method is equivalent to calling: translation(tx, ty, tz).rotate(quat)
tx - the number of units by which to translate the x-componentty - the number of units by which to translate the y-componenttz - the number of units by which to translate the z-componentqx - the x-coordinate of the vector part of the quaternionqy - the y-coordinate of the vector part of the quaternionqz - the z-coordinate of the vector part of the quaternionqw - the scalar part of the quaterniontranslation(float, float, float),
rotate(Quaternionfc)public Matrix4f translationRotate(float tx, float ty, float tz, Quaternionfc quat)
this matrix to T * R, where T is a translation by the given (tx, ty, tz) and
R is a rotation - and possibly scaling - transformation specified by the given quaternion.
When transforming a vector by the resulting matrix the rotation - and possibly scaling - transformation will be applied first and then the translation.
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.
This method is equivalent to calling: translation(tx, ty, tz).rotate(quat)
tx - the number of units by which to translate the x-componentty - the number of units by which to translate the y-componenttz - the number of units by which to translate the z-componentquat - the quaternion representing a rotationtranslation(float, float, float),
rotate(Quaternionfc)public Matrix4f set3x3(Matrix3fc mat)
Matrix4f to the given Matrix3fc and don't change the other elements.mat - the 3x3 matrixpublic Vector4f transform(Vector4f v)
Matrix4fctransform in interface Matrix4fcv - the vector to transform and to hold the final resultVector4f.mul(Matrix4fc)public Vector4f transform(Vector4fc v, Vector4f dest)
Matrix4fcdest.transform in interface Matrix4fcv - the vector to transformdest - will contain the resultVector4f.mul(Matrix4fc, Vector4f)public Vector4f transform(float x, float y, float z, float w, Vector4f dest)
Matrix4fc(x, y, z, w) by this matrix and store the result in dest.public Vector4f transformProject(Vector4f v)
Matrix4fctransformProject in interface Matrix4fcv - the vector to transform and to hold the final resultVector4f.mulProject(Matrix4fc)public Vector4f transformProject(Vector4fc v, Vector4f dest)
Matrix4fcdest.transformProject in interface Matrix4fcv - the vector to transformdest - will contain the resultVector4f.mulProject(Matrix4fc, Vector4f)public Vector4f transformProject(float x, float y, float z, float w, Vector4f dest)
Matrix4fc(x, y, z, w) by this matrix, perform perspective divide and store the result in dest.transformProject in interface Matrix4fcx - the x coordinate of the vector to transformy - the y coordinate of the vector to transformz - the z coordinate of the vector to transformw - the w coordinate of the vector to transformdest - will contain the resultpublic Vector3f transformProject(Vector3f v)
Matrix4fc
This method uses w=1.0 as the fourth vector component.
transformProject in interface Matrix4fcv - the vector to transform and to hold the final resultVector3f.mulProject(Matrix4fc)public Vector3f transformProject(Vector3fc v, Vector3f dest)
Matrix4fcdest.
This method uses w=1.0 as the fourth vector component.
transformProject in interface Matrix4fcv - the vector to transformdest - will contain the resultVector3f.mulProject(Matrix4fc, Vector3f)public Vector3f transformProject(float x, float y, float z, Vector3f dest)
Matrix4fc(x, y, z) by this matrix, perform perspective divide and store the result in dest.
This method uses w=1.0 as the fourth vector component.
transformProject in interface Matrix4fcx - the x coordinate of the vector to transformy - the y coordinate of the vector to transformz - the z coordinate of the vector to transformdest - will contain the resultpublic Vector3f transformPosition(Vector3f v)
Matrix4fc
The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it
will represent a position/location in 3D-space rather than a direction. This method is therefore
not suited for perspective projection transformations as it will not save the
w component of the transformed vector.
For perspective projection use Matrix4fc.transform(Vector4f) or Matrix4fc.transformProject(Vector3f)
when perspective divide should be applied, too.
In order to store the result in another vector, use Matrix4fc.transformPosition(Vector3fc, Vector3f).
transformPosition in interface Matrix4fcv - the vector to transform and to hold the final resultMatrix4fc.transformPosition(Vector3fc, Vector3f),
Matrix4fc.transform(Vector4f),
Matrix4fc.transformProject(Vector3f)public Vector3f transformPosition(Vector3fc v, Vector3f dest)
Matrix4fcdest.
The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it
will represent a position/location in 3D-space rather than a direction. This method is therefore
not suited for perspective projection transformations as it will not save the
w component of the transformed vector.
For perspective projection use Matrix4fc.transform(Vector4fc, Vector4f) or
Matrix4fc.transformProject(Vector3fc, Vector3f) when perspective divide should be applied, too.
In order to store the result in the same vector, use Matrix4fc.transformPosition(Vector3f).
transformPosition in interface Matrix4fcv - the vector to transformdest - will hold the resultMatrix4fc.transformPosition(Vector3f),
Matrix4fc.transform(Vector4fc, Vector4f),
Matrix4fc.transformProject(Vector3fc, Vector3f)public Vector3f transformPosition(float x, float y, float z, Vector3f dest)
Matrix4fc(x, y, z), as if it was a 4D-vector with w=1, by
this matrix and store the result in dest.
The given 3D-vector is treated as a 4D-vector with its w-component being 1.0, so it
will represent a position/location in 3D-space rather than a direction. This method is therefore
not suited for perspective projection transformations as it will not save the
w component of the transformed vector.
For perspective projection use Matrix4fc.transform(float, float, float, float, Vector4f) or
Matrix4fc.transformProject(float, float, float, Vector3f) when perspective divide should be applied, too.
transformPosition in interface Matrix4fcx - the x coordinate of the positiony - the y coordinate of the positionz - the z coordinate of the positiondest - will hold the resultMatrix4fc.transform(float, float, float, float, Vector4f),
Matrix4fc.transformProject(float, float, float, Vector3f)public Vector3f transformDirection(Vector3f v)
Matrix4fc
The given 3D-vector is treated as a 4D-vector with its w-component being 0.0, so it
will represent a direction in 3D-space rather than a position. This method will therefore
not take the translation part of the matrix into account.
In order to store the result in another vector, use Matrix4fc.transformDirection(Vector3fc, Vector3f).
transformDirection in interface Matrix4fcv - the vector to transform and to hold the final resultMatrix4fc.transformDirection(Vector3fc, Vector3f)public Vector3f transformDirection(Vector3fc v, Vector3f dest)
Matrix4fcdest.
The given 3D-vector is treated as a 4D-vector with its w-component being 0.0, so it
will represent a direction in 3D-space rather than a position. This method will therefore
not take the translation part of the matrix into account.
In order to store the result in the same vector, use Matrix4fc.transformDirection(Vector3f).
transformDirection in interface Matrix4fcv - the vector to transform and to hold the final resultdest - will hold the resultMatrix4fc.transformDirection(Vector3f)public Vector3f transformDirection(float x, float y, float z, Vector3f dest)
Matrix4fc(x, y, z), as if it was a 4D-vector with w=0, by
this matrix and store the result in dest.
The given 3D-vector is treated as a 4D-vector with its w-component being 0.0, so it
will represent a direction in 3D-space rather than a position. This method will therefore
not take the translation part of the matrix into account.
transformDirection in interface Matrix4fcx - the x coordinate of the direction to transformy - the y coordinate of the direction to transformz - the z coordinate of the direction to transformdest - will hold the resultpublic Vector4f transformAffine(Vector4f v)
Matrix4fcthis matrix represents an affine transformation
(i.e. its last row is equal to (0, 0, 0, 1)).
In order to store the result in another vector, use Matrix4fc.transformAffine(Vector4fc, Vector4f).
transformAffine in interface Matrix4fcv - the vector to transform and to hold the final resultMatrix4fc.transformAffine(Vector4fc, Vector4f)public Vector4f transformAffine(Vector4fc v, Vector4f dest)
Matrix4fcthis matrix represents an affine transformation
(i.e. its last row is equal to (0, 0, 0, 1)) and store the result in dest.
In order to store the result in the same vector, use Matrix4fc.transformAffine(Vector4f).
transformAffine in interface Matrix4fcv - the vector to transform and to hold the final resultdest - will hold the resultMatrix4fc.transformAffine(Vector4f)public Vector4f transformAffine(float x, float y, float z, float w, Vector4f dest)
Matrix4fc(x, y, z, w) by assuming that this matrix represents an affine transformation
(i.e. its last row is equal to (0, 0, 0, 1)) and store the result in dest.transformAffine in interface Matrix4fcx - the x coordinate of the direction to transformy - the y coordinate of the direction to transformz - the z coordinate of the direction to transformw - the w coordinate of the direction to transformdest - will hold the resultpublic Matrix4f scale(Vector3fc xyz, Matrix4f dest)
Matrix4fcthis matrix by scaling the base axes by the given xyz.x,
xyz.y and xyz.z factors, respectively and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v
, the scaling will be applied first!
public Matrix4f scale(Vector3fc xyz)
xyz.x,
xyz.y and xyz.z factors, respectively.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
xyz - the factors of the x, y and z component, respectivelypublic Matrix4f scale(float xyz, Matrix4f dest)
Matrix4fcxyz factor
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
Individual scaling of all three axes can be applied using Matrix4fc.scale(float, float, float, Matrix4f).
scale in interface Matrix4fcxyz - the factor for all componentsdest - will hold the resultMatrix4fc.scale(float, float, float, Matrix4f)public Matrix4f scale(float xyz)
xyz factor.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
Individual scaling of all three axes can be applied using scale(float, float, float).
xyz - the factor for all componentsscale(float, float, float)public Matrix4f scaleXY(float x, float y, Matrix4f dest)
Matrix4fcx and the Y axis by y
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
public Matrix4f scaleXY(float x, float y)
x and the Y axis by y.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
x - the factor of the x componenty - the factor of the y componentpublic Matrix4f scale(float x, float y, float z, Matrix4f dest)
Matrix4fcthis matrix by scaling the base axes by the given x,
y and z factors and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v
, the scaling will be applied first!
public Matrix4f scale(float x, float y, float z)
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
x - the factor of the x componenty - the factor of the y componentz - the factor of the z componentpublic Matrix4f scaleAround(float sx, float sy, float sz, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcthis matrix by scaling the base axes by the given sx,
sy and sz factors while using (ox, oy, oz) as the scaling origin,
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v
, the scaling will be applied first!
This method is equivalent to calling: translate(ox, oy, oz, dest).scale(sx, sy, sz).translate(-ox, -oy, -oz)
scaleAround in interface Matrix4fcsx - the scaling factor of the x componentsy - the scaling factor of the y componentsz - the scaling factor of the z componentox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling origindest - will hold the resultpublic Matrix4f scaleAround(float sx, float sy, float sz, float ox, float oy, float oz)
(ox, oy, oz) as the scaling origin.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
This method is equivalent to calling: translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz)
sx - the scaling factor of the x componentsy - the scaling factor of the y componentsz - the scaling factor of the z componentox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling originpublic Matrix4f scaleAround(float factor, float ox, float oy, float oz)
factor
while using (ox, oy, oz) as the scaling origin.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
This method is equivalent to calling: translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz)
factor - the scaling factor for all three axesox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling originpublic Matrix4f scaleAround(float factor, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcfactor
while using (ox, oy, oz) as the scaling origin,
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
scaling will be applied first!
This method is equivalent to calling: translate(ox, oy, oz, dest).scale(factor).translate(-ox, -oy, -oz)
scaleAround in interface Matrix4fcfactor - the scaling factor for all three axesox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling origindest - will hold the resultpublic Matrix4f scaleLocal(float x, float y, float z, Matrix4f dest)
Matrix4fcthis matrix by scaling the base axes by the given x,
y and z factors and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v
, the scaling will be applied last!
scaleLocal in interface Matrix4fcx - the factor of the x componenty - the factor of the y componentz - the factor of the z componentdest - will hold the resultpublic Matrix4f scaleLocal(float xyz, Matrix4f dest)
Matrix4fcthis matrix by scaling all base axes by the given xyz factor,
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v
, the scaling will be applied last!
scaleLocal in interface Matrix4fcxyz - the factor to scale all three base axes bydest - will hold the resultpublic Matrix4f scaleLocal(float xyz)
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v, the
scaling will be applied last!
xyz - the factor of the x, y and z componentpublic Matrix4f scaleLocal(float x, float y, float z)
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v, the
scaling will be applied last!
x - the factor of the x componenty - the factor of the y componentz - the factor of the z componentpublic Matrix4f scaleAroundLocal(float sx, float sy, float sz, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcthis matrix by scaling the base axes by the given sx,
sy and sz factors while using the given (ox, oy, oz) as the scaling origin,
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v
, the scaling will be applied last!
This method is equivalent to calling: new Matrix4f().translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz).mul(this, dest)
scaleAroundLocal in interface Matrix4fcsx - the scaling factor of the x componentsy - the scaling factor of the y componentsz - the scaling factor of the z componentox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling origindest - will hold the resultpublic Matrix4f scaleAroundLocal(float sx, float sy, float sz, float ox, float oy, float oz)
(ox, oy, oz) as the scaling origin.
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v, the
scaling will be applied last!
This method is equivalent to calling: new Matrix4f().translate(ox, oy, oz).scale(sx, sy, sz).translate(-ox, -oy, -oz).mul(this, this)
sx - the scaling factor of the x componentsy - the scaling factor of the y componentsz - the scaling factor of the z componentox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling originpublic Matrix4f scaleAroundLocal(float factor, float ox, float oy, float oz)
factor
while using (ox, oy, oz) as the scaling origin.
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v, the
scaling will be applied last!
This method is equivalent to calling: new Matrix4f().translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz).mul(this, this)
factor - the scaling factor for all three axesox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling originpublic Matrix4f scaleAroundLocal(float factor, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcfactor
while using (ox, oy, oz) as the scaling origin,
and store the result in dest.
If M is this matrix and S the scaling matrix,
then the new matrix will be S * M. So when transforming a
vector v with the new matrix by using S * M * v, the
scaling will be applied last!
This method is equivalent to calling: new Matrix4f().translate(ox, oy, oz).scale(factor).translate(-ox, -oy, -oz).mul(this, dest)
scaleAroundLocal in interface Matrix4fcfactor - the scaling factor for all three axesox - the x coordinate of the scaling originoy - the y coordinate of the scaling originoz - the z coordinate of the scaling origindest - will hold the resultpublic Matrix4f rotateX(float ang, Matrix4f dest)
Matrix4fcdest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
Reference: http://en.wikipedia.org
public Matrix4f rotateX(float ang)
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
Reference: http://en.wikipedia.org
ang - the angle in radianspublic Matrix4f rotateY(float ang, Matrix4f dest)
Matrix4fcdest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
Reference: http://en.wikipedia.org
public Matrix4f rotateY(float ang)
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
Reference: http://en.wikipedia.org
ang - the angle in radianspublic Matrix4f rotateZ(float ang, Matrix4f dest)
Matrix4fcdest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
Reference: http://en.wikipedia.org
public Matrix4f rotateZ(float ang)
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
Reference: http://en.wikipedia.org
ang - the angle in radianspublic Matrix4f rotateTowardsXY(float dirX, float dirY)
+X towards (dirX, dirY).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
The vector (dirX, dirY) must be a unit vector.
dirX - the x component of the normalized directiondirY - the y component of the normalized directionpublic Matrix4f rotateTowardsXY(float dirX, float dirY, Matrix4f dest)
Matrix4fc+X towards (dirX, dirY) and store the result in dest.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
The vector (dirX, dirY) must be a unit vector.
rotateTowardsXY in interface Matrix4fcdirX - the x component of the normalized directiondirY - the y component of the normalized directiondest - will hold the resultpublic Matrix4f rotateXYZ(Vector3f angles)
angles.x radians about the X axis, followed by a rotation of angles.y radians about the Y axis and
followed by a rotation of angles.z radians about the Z axis.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateX(angles.x).rotateY(angles.y).rotateZ(angles.z)
angles - the Euler anglespublic Matrix4f rotateXYZ(float angleX, float angleY, float angleZ)
angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateX(angleX).rotateY(angleY).rotateZ(angleZ)
angleX - the angle to rotate about XangleY - the angle to rotate about YangleZ - the angle to rotate about Zpublic Matrix4f rotateXYZ(float angleX, float angleY, float angleZ, Matrix4f dest)
Matrix4fcangleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)
public Matrix4f rotateAffineXYZ(float angleX, float angleY, float angleZ)
angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis.
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.
This method assumes that this matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateX(angleX).rotateY(angleY).rotateZ(angleZ)
angleX - the angle to rotate about XangleY - the angle to rotate about YangleZ - the angle to rotate about Zpublic Matrix4f rotateAffineXYZ(float angleX, float angleY, float angleZ, Matrix4f dest)
Matrix4fcangleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest.
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.
This method assumes that this matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
rotateAffineXYZ in interface Matrix4fcangleX - the angle to rotate about XangleY - the angle to rotate about YangleZ - the angle to rotate about Zdest - will hold the resultpublic Matrix4f rotateZYX(Vector3f angles)
angles.z radians about the Z axis, followed by a rotation of angles.y radians about the Y axis and
followed by a rotation of angles.x radians about the X axis.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateZ(angles.z).rotateY(angles.y).rotateX(angles.x)
angles - the Euler anglespublic Matrix4f rotateZYX(float angleZ, float angleY, float angleX)
angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateZ(angleZ).rotateY(angleY).rotateX(angleX)
angleZ - the angle to rotate about ZangleY - the angle to rotate about YangleX - the angle to rotate about Xpublic Matrix4f rotateZYX(float angleZ, float angleY, float angleX, Matrix4f dest)
Matrix4fcangleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis and store the result in dest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)
public Matrix4f rotateAffineZYX(float angleZ, float angleY, float angleX)
angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis.
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.
This method assumes that this matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
angleZ - the angle to rotate about ZangleY - the angle to rotate about YangleX - the angle to rotate about Xpublic Matrix4f rotateAffineZYX(float angleZ, float angleY, float angleX, Matrix4f dest)
Matrix4fcangleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and
followed by a rotation of angleX radians about the X axis and store the result in dest.
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.
This method assumes that this matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
rotateAffineZYX in interface Matrix4fcangleZ - the angle to rotate about ZangleY - the angle to rotate about YangleX - the angle to rotate about Xdest - will hold the resultpublic Matrix4f rotateYXZ(Vector3f angles)
angles.y radians about the Y axis, followed by a rotation of angles.x radians about the X axis and
followed by a rotation of angles.z radians about the Z axis.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateY(angles.y).rotateX(angles.x).rotateZ(angles.z)
angles - the Euler anglespublic Matrix4f rotateYXZ(float angleY, float angleX, float angleZ)
angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateY(angleY).rotateX(angleX).rotateZ(angleZ)
angleY - the angle to rotate about YangleX - the angle to rotate about XangleZ - the angle to rotate about Zpublic Matrix4f rotateYXZ(float angleY, float angleX, float angleZ, Matrix4f dest)
Matrix4fcangleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
This method is equivalent to calling: rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)
public Matrix4f rotateAffineYXZ(float angleY, float angleX, float angleZ)
angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis.
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.
This method assumes that this matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
angleY - the angle to rotate about YangleX - the angle to rotate about XangleZ - the angle to rotate about Zpublic Matrix4f rotateAffineYXZ(float angleY, float angleX, float angleZ, Matrix4f dest)
Matrix4fcangleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and
followed by a rotation of angleZ radians about the Z axis and store the result in dest.
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.
This method assumes that this matrix represents an affine transformation (i.e. its last row is equal to (0, 0, 0, 1))
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).
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
rotateAffineYXZ in interface Matrix4fcangleY - the angle to rotate about YangleX - the angle to rotate about XangleZ - the angle to rotate about Zdest - will hold the resultpublic Matrix4f rotate(float ang, float x, float y, float z, Matrix4f dest)
(x, y, z) axis and store the result in dest.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
In order to set the matrix to a rotation matrix without post-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
rotate in interface Matrix4fcang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisdest - will hold the resultrotation(float, float, float, float)public Matrix4f rotate(float ang, float x, float y, float z)
(x, y, z) axis.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
In order to set the matrix to a rotation matrix without post-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
ang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisrotation(float, float, float, float)public Matrix4f rotateTranslation(float ang, float x, float y, float z, Matrix4f dest)
(x, y, z) axis and store the result in dest.
This method assumes this to only contain a translation.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
In order to set the matrix to a rotation matrix without post-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
rotateTranslation in interface Matrix4fcang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisdest - will hold the resultrotation(float, float, float, float)public Matrix4f rotateAffine(float ang, float x, float y, float z, Matrix4f dest)
affine matrix by rotating the given amount of radians
about the specified (x, y, z) axis and store the result in dest.
This method assumes this to be affine.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
In order to set the matrix to a rotation matrix without post-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
rotateAffine in interface Matrix4fcang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisdest - will hold the resultrotation(float, float, float, float)public Matrix4f rotateAffine(float ang, float x, float y, float z)
affine matrix by rotating the given amount of radians
about the specified (x, y, z) axis.
This method assumes this to be affine.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
rotation will be applied first!
In order to set the matrix to a rotation matrix without post-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
ang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisrotation(float, float, float, float)public Matrix4f rotateLocal(float ang, float x, float y, float z, Matrix4f dest)
(x, y, z) axis and store the result in dest.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
rotateLocal in interface Matrix4fcang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisdest - will hold the resultrotation(float, float, float, float)public Matrix4f rotateLocal(float ang, float x, float y, float z)
(x, y, z) axis.
The axis described by the three components needs to be a unit vector.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotation().
Reference: http://en.wikipedia.org
ang - the angle in radiansx - the x component of the axisy - the y component of the axisz - the z component of the axisrotation(float, float, float, float)public Matrix4f rotateLocalX(float ang, Matrix4f dest)
dest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotationX().
Reference: http://en.wikipedia.org
rotateLocalX in interface Matrix4fcang - the angle in radians to rotate about the X axisdest - will hold the resultrotationX(float)public Matrix4f rotateLocalX(float ang)
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotationX().
Reference: http://en.wikipedia.org
ang - the angle in radians to rotate about the X axisrotationX(float)public Matrix4f rotateLocalY(float ang, Matrix4f dest)
dest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotationY().
Reference: http://en.wikipedia.org
rotateLocalY in interface Matrix4fcang - the angle in radians to rotate about the Y axisdest - will hold the resultrotationY(float)public Matrix4f rotateLocalY(float ang)
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotationY().
Reference: http://en.wikipedia.org
ang - the angle in radians to rotate about the Y axisrotationY(float)public Matrix4f rotateLocalZ(float ang, Matrix4f dest)
dest.
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotationZ().
Reference: http://en.wikipedia.org
rotateLocalZ in interface Matrix4fcang - the angle in radians to rotate about the Z axisdest - will hold the resultrotationZ(float)public Matrix4f rotateLocalZ(float ang)
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.
If M is this matrix and R the rotation matrix,
then the new matrix will be R * M. So when transforming a
vector v with the new matrix by using R * M * v, the
rotation will be applied last!
In order to set the matrix to a rotation matrix without pre-multiplying the rotation
transformation, use rotationY().
Reference: http://en.wikipedia.org
ang - the angle in radians to rotate about the Z axisrotationY(float)public Matrix4f translate(Vector3fc offset)
If M is this matrix and T the translation
matrix, then the new matrix will be M * T. So when
transforming a vector v with the new matrix by using
M * T * v, the translation will be applied first!
In order to set the matrix to a translation transformation without post-multiplying
it, use translation(Vector3fc).
offset - the number of units in x, y and z by which to translatetranslation(Vector3fc)public Matrix4f translate(Vector3fc offset, Matrix4f dest)
dest.
If M is this matrix and T the translation
matrix, then the new matrix will be M * T. So when
transforming a vector v with the new matrix by using
M * T * v, the translation will be applied first!
In order to set the matrix to a translation transformation without post-multiplying
it, use translation(Vector3fc).
translate in interface Matrix4fcoffset - the number of units in x, y and z by which to translatedest - will hold the resulttranslation(Vector3fc)public Matrix4f translate(float x, float y, float z, Matrix4f dest)
dest.
If M is this matrix and T the translation
matrix, then the new matrix will be M * T. So when
transforming a vector v with the new matrix by using
M * T * v, the translation will be applied first!
In order to set the matrix to a translation transformation without post-multiplying
it, use translation(float, float, float).
translate in interface Matrix4fcx - the offset to translate in xy - the offset to translate in yz - the offset to translate in zdest - will hold the resulttranslation(float, float, float)public Matrix4f translate(float x, float y, float z)
If M is this matrix and T the translation
matrix, then the new matrix will be M * T. So when
transforming a vector v with the new matrix by using
M * T * v, the translation will be applied first!
In order to set the matrix to a translation transformation without post-multiplying
it, use translation(float, float, float).
x - the offset to translate in xy - the offset to translate in yz - the offset to translate in ztranslation(float, float, float)public Matrix4f translateLocal(Vector3fc offset)
If M is this matrix and T the translation
matrix, then the new matrix will be T * M. So when
transforming a vector v with the new matrix by using
T * M * v, the translation will be applied last!
In order to set the matrix to a translation transformation without pre-multiplying
it, use translation(Vector3fc).
offset - the number of units in x, y and z by which to translatetranslation(Vector3fc)public Matrix4f translateLocal(Vector3fc offset, Matrix4f dest)
dest.
If M is this matrix and T the translation
matrix, then the new matrix will be T * M. So when
transforming a vector v with the new matrix by using
T * M * v, the translation will be applied last!
In order to set the matrix to a translation transformation without pre-multiplying
it, use translation(Vector3fc).
translateLocal in interface Matrix4fcoffset - the number of units in x, y and z by which to translatedest - will hold the resulttranslation(Vector3fc)public Matrix4f translateLocal(float x, float y, float z, Matrix4f dest)
dest.
If M is this matrix and T the translation
matrix, then the new matrix will be T * M. So when
transforming a vector v with the new matrix by using
T * M * v, the translation will be applied last!
In order to set the matrix to a translation transformation without pre-multiplying
it, use translation(float, float, float).
translateLocal in interface Matrix4fcx - the offset to translate in xy - the offset to translate in yz - the offset to translate in zdest - will hold the resulttranslation(float, float, float)public Matrix4f translateLocal(float x, float y, float z)
If M is this matrix and T the translation
matrix, then the new matrix will be T * M. So when
transforming a vector v with the new matrix by using
T * M * v, the translation will be applied last!
In order to set the matrix to a translation transformation without pre-multiplying
it, use translation(float, float, float).
x - the offset to translate in xy - the offset to translate in yz - the offset to translate in ztranslation(float, float, float)public void writeExternal(ObjectOutput out) throws IOException
writeExternal in interface ExternalizableIOExceptionpublic void readExternal(ObjectInput in) throws IOException
readExternal in interface ExternalizableIOExceptionpublic Matrix4f ortho(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho().
Reference: http://www.songho.ca
ortho in interface Matrix4fcleft - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsedest - will hold the resultsetOrtho(float, float, float, float, float, float, boolean)public Matrix4f ortho(float left, float right, float bottom, float top, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho().
Reference: http://www.songho.ca
ortho in interface Matrix4fcleft - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancedest - will hold the resultsetOrtho(float, float, float, float, float, float)public Matrix4f ortho(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetOrtho(float, float, float, float, float, float, boolean)public Matrix4f ortho(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1] to this matrix.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancesetOrtho(float, float, float, float, float, float)public Matrix4f orthoLH(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrthoLH().
Reference: http://www.songho.ca
orthoLH in interface Matrix4fcleft - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsedest - will hold the resultsetOrthoLH(float, float, float, float, float, float, boolean)public Matrix4f orthoLH(float left, float right, float bottom, float top, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrthoLH().
Reference: http://www.songho.ca
orthoLH in interface Matrix4fcleft - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancedest - will hold the resultsetOrthoLH(float, float, float, float, float, float)public Matrix4f orthoLH(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrthoLH().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetOrthoLH(float, float, float, float, float, float, boolean)public Matrix4f orthoLH(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1] to this matrix.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrthoLH().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancesetOrthoLH(float, float, float, float, float, float)public Matrix4f setOrtho(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
In order to apply the orthographic projection to an already existing transformation,
use ortho().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseortho(float, float, float, float, float, float, boolean)public Matrix4f setOrtho(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1].
In order to apply the orthographic projection to an already existing transformation,
use ortho().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distanceortho(float, float, float, float, float, float)public Matrix4f setOrthoLH(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
In order to apply the orthographic projection to an already existing transformation,
use orthoLH().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseorthoLH(float, float, float, float, float, float, boolean)public Matrix4f setOrthoLH(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1].
In order to apply the orthographic projection to an already existing transformation,
use orthoLH().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgezNear - near clipping plane distancezFar - far clipping plane distanceorthoLH(float, float, float, float, float, float)public Matrix4f orthoSymmetric(float width, float height, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
This method is equivalent to calling ortho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetric().
Reference: http://www.songho.ca
orthoSymmetric in interface Matrix4fcwidth - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancedest - will hold the resultzZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetOrthoSymmetric(float, float, float, float, boolean)public Matrix4f orthoSymmetric(float width, float height, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
This method is equivalent to calling ortho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetric().
Reference: http://www.songho.ca
orthoSymmetric in interface Matrix4fcwidth - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancedest - will hold the resultsetOrthoSymmetric(float, float, float, float)public Matrix4f orthoSymmetric(float width, float height, float zNear, float zFar, boolean zZeroToOne)
This method is equivalent to calling ortho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetric().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetOrthoSymmetric(float, float, float, float, boolean)public Matrix4f orthoSymmetric(float width, float height, float zNear, float zFar)
[-1..+1] to this matrix.
This method is equivalent to calling ortho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetric().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancesetOrthoSymmetric(float, float, float, float)public Matrix4f orthoSymmetricLH(float width, float height, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
This method is equivalent to calling orthoLH() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetricLH().
Reference: http://www.songho.ca
orthoSymmetricLH in interface Matrix4fcwidth - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancedest - will hold the resultzZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetOrthoSymmetricLH(float, float, float, float, boolean)public Matrix4f orthoSymmetricLH(float width, float height, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
This method is equivalent to calling orthoLH() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetricLH().
Reference: http://www.songho.ca
orthoSymmetricLH in interface Matrix4fcwidth - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancedest - will hold the resultsetOrthoSymmetricLH(float, float, float, float)public Matrix4f orthoSymmetricLH(float width, float height, float zNear, float zFar, boolean zZeroToOne)
This method is equivalent to calling orthoLH() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetricLH().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetOrthoSymmetricLH(float, float, float, float, boolean)public Matrix4f orthoSymmetricLH(float width, float height, float zNear, float zFar)
[-1..+1] to this matrix.
This method is equivalent to calling orthoLH() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to a symmetric orthographic projection without post-multiplying it,
use setOrthoSymmetricLH().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancesetOrthoSymmetricLH(float, float, float, float)public Matrix4f setOrthoSymmetric(float width, float height, float zNear, float zFar, boolean zZeroToOne)
This method is equivalent to calling setOrtho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
In order to apply the symmetric orthographic projection to an already existing transformation,
use orthoSymmetric().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseorthoSymmetric(float, float, float, float, boolean)public Matrix4f setOrthoSymmetric(float width, float height, float zNear, float zFar)
[-1..+1].
This method is equivalent to calling setOrtho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
In order to apply the symmetric orthographic projection to an already existing transformation,
use orthoSymmetric().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distanceorthoSymmetric(float, float, float, float)public Matrix4f setOrthoSymmetricLH(float width, float height, float zNear, float zFar, boolean zZeroToOne)
This method is equivalent to calling setOrtho() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
In order to apply the symmetric orthographic projection to an already existing transformation,
use orthoSymmetricLH().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distancezZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseorthoSymmetricLH(float, float, float, float, boolean)public Matrix4f setOrthoSymmetricLH(float width, float height, float zNear, float zFar)
[-1..+1].
This method is equivalent to calling setOrthoLH() with
left=-width/2, right=+width/2, bottom=-height/2 and top=+height/2.
In order to apply the symmetric orthographic projection to an already existing transformation,
use orthoSymmetricLH().
Reference: http://www.songho.ca
width - the distance between the right and left frustum edgesheight - the distance between the top and bottom frustum edgeszNear - near clipping plane distancezFar - far clipping plane distanceorthoSymmetricLH(float, float, float, float)public Matrix4f ortho2D(float left, float right, float bottom, float top, Matrix4f dest)
dest.
This method is equivalent to calling ortho() with
zNear=-1 and zFar=+1.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho().
Reference: http://www.songho.ca
ortho2D in interface Matrix4fcleft - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgedest - will hold the resultortho(float, float, float, float, float, float, Matrix4f),
setOrtho2D(float, float, float, float)public Matrix4f ortho2D(float left, float right, float bottom, float top)
This method is equivalent to calling ortho() with
zNear=-1 and zFar=+1.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho2D().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgeortho(float, float, float, float, float, float),
setOrtho2D(float, float, float, float)public Matrix4f ortho2DLH(float left, float right, float bottom, float top, Matrix4f dest)
dest.
This method is equivalent to calling orthoLH() with
zNear=-1 and zFar=+1.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrthoLH().
Reference: http://www.songho.ca
ortho2DLH in interface Matrix4fcleft - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgedest - will hold the resultorthoLH(float, float, float, float, float, float, Matrix4f),
setOrtho2DLH(float, float, float, float)public Matrix4f ortho2DLH(float left, float right, float bottom, float top)
This method is equivalent to calling orthoLH() with
zNear=-1 and zFar=+1.
If M is this matrix and O the orthographic projection matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
orthographic projection transformation will be applied first!
In order to set the matrix to an orthographic projection without post-multiplying it,
use setOrtho2DLH().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgeorthoLH(float, float, float, float, float, float),
setOrtho2DLH(float, float, float, float)public Matrix4f setOrtho2D(float left, float right, float bottom, float top)
This method is equivalent to calling setOrtho() with
zNear=-1 and zFar=+1.
In order to apply the orthographic projection to an already existing transformation,
use ortho2D().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgesetOrtho(float, float, float, float, float, float),
ortho2D(float, float, float, float)public Matrix4f setOrtho2DLH(float left, float right, float bottom, float top)
This method is equivalent to calling setOrthoLH() with
zNear=-1 and zFar=+1.
In order to apply the orthographic projection to an already existing transformation,
use ortho2DLH().
Reference: http://www.songho.ca
left - the distance from the center to the left frustum edgeright - the distance from the center to the right frustum edgebottom - the distance from the center to the bottom frustum edgetop - the distance from the center to the top frustum edgesetOrthoLH(float, float, float, float, float, float),
ortho2DLH(float, float, float, float)public Matrix4f lookAlong(Vector3fc dir, Vector3fc up)
-z point along dir.
If M is this matrix and L the lookalong rotation matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v, the
lookalong rotation transformation will be applied first!
This is equivalent to calling
lookAt
with eye = (0, 0, 0) and center = dir.
In order to set the matrix to a lookalong transformation without post-multiplying it,
use setLookAlong().
dir - the direction in space to look alongup - the direction of 'up'lookAlong(float, float, float, float, float, float),
lookAt(Vector3fc, Vector3fc, Vector3fc),
setLookAlong(Vector3fc, Vector3fc)public Matrix4f lookAlong(Vector3fc dir, Vector3fc up, Matrix4f dest)
-z point along dir
and store the result in dest.
If M is this matrix and L the lookalong rotation matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v, the
lookalong rotation transformation will be applied first!
This is equivalent to calling
lookAt
with eye = (0, 0, 0) and center = dir.
In order to set the matrix to a lookalong transformation without post-multiplying it,
use setLookAlong().
lookAlong in interface Matrix4fcdir - the direction in space to look alongup - the direction of 'up'dest - will hold the resultlookAlong(float, float, float, float, float, float),
lookAt(Vector3fc, Vector3fc, Vector3fc),
setLookAlong(Vector3fc, Vector3fc)public Matrix4f lookAlong(float dirX, float dirY, float dirZ, float upX, float upY, float upZ, Matrix4f dest)
-z point along dir
and store the result in dest.
If M is this matrix and L the lookalong rotation matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v, the
lookalong rotation transformation will be applied first!
This is equivalent to calling
lookAt()
with eye = (0, 0, 0) and center = dir.
In order to set the matrix to a lookalong transformation without post-multiplying it,
use setLookAlong()
lookAlong in interface Matrix4fcdirX - the x-coordinate of the direction to look alongdirY - the y-coordinate of the direction to look alongdirZ - the z-coordinate of the direction to look alongupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectordest - will hold the resultlookAt(float, float, float, float, float, float, float, float, float),
setLookAlong(float, float, float, float, float, float)public Matrix4f lookAlong(float dirX, float dirY, float dirZ, float upX, float upY, float upZ)
-z point along dir.
If M is this matrix and L the lookalong rotation matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v, the
lookalong rotation transformation will be applied first!
This is equivalent to calling
lookAt()
with eye = (0, 0, 0) and center = dir.
In order to set the matrix to a lookalong transformation without post-multiplying it,
use setLookAlong()
dirX - the x-coordinate of the direction to look alongdirY - the y-coordinate of the direction to look alongdirZ - the z-coordinate of the direction to look alongupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorlookAt(float, float, float, float, float, float, float, float, float),
setLookAlong(float, float, float, float, float, float)public Matrix4f setLookAlong(Vector3fc dir, Vector3fc up)
-z
point along dir.
This is equivalent to calling
setLookAt()
with eye = (0, 0, 0) and center = dir.
In order to apply the lookalong transformation to any previous existing transformation,
use lookAlong(Vector3fc, Vector3fc).
dir - the direction in space to look alongup - the direction of 'up'setLookAlong(Vector3fc, Vector3fc),
lookAlong(Vector3fc, Vector3fc)public Matrix4f setLookAlong(float dirX, float dirY, float dirZ, float upX, float upY, float upZ)
-z
point along dir.
This is equivalent to calling
setLookAt() with eye = (0, 0, 0) and center = dir.
In order to apply the lookalong transformation to any previous existing transformation,
use lookAlong()
dirX - the x-coordinate of the direction to look alongdirY - the y-coordinate of the direction to look alongdirZ - the z-coordinate of the direction to look alongupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorsetLookAlong(float, float, float, float, float, float),
lookAlong(float, float, float, float, float, float)public Matrix4f setLookAt(Vector3fc eye, Vector3fc center, Vector3fc up)
-z with center - eye.
In order to not make use of vectors to specify eye, center and up but use primitives,
like in the GLU function, use setLookAt()
instead.
In order to apply the lookat transformation to a previous existing transformation,
use lookAt().
eye - the position of the cameracenter - the point in space to look atup - the direction of 'up'setLookAt(float, float, float, float, float, float, float, float, float),
lookAt(Vector3fc, Vector3fc, Vector3fc)public Matrix4f setLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
-z with center - eye.
In order to apply the lookat transformation to a previous existing transformation,
use lookAt.
eyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorsetLookAt(Vector3fc, Vector3fc, Vector3fc),
lookAt(float, float, float, float, float, float, float, float, float)public Matrix4f lookAt(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4f dest)
-z with center - eye and store the result in dest.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAt(Vector3fc, Vector3fc, Vector3fc).
lookAt in interface Matrix4fceye - the position of the cameracenter - the point in space to look atup - the direction of 'up'dest - will hold the resultlookAt(float, float, float, float, float, float, float, float, float),
setLookAlong(Vector3fc, Vector3fc)public Matrix4f lookAt(Vector3fc eye, Vector3fc center, Vector3fc up)
-z with center - eye.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAt(Vector3fc, Vector3fc, Vector3fc).
eye - the position of the cameracenter - the point in space to look atup - the direction of 'up'lookAt(float, float, float, float, float, float, float, float, float),
setLookAlong(Vector3fc, Vector3fc)public Matrix4f lookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ, Matrix4f dest)
-z with center - eye and store the result in dest.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAt().
lookAt in interface Matrix4fceyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectordest - will hold the resultlookAt(Vector3fc, Vector3fc, Vector3fc),
setLookAt(float, float, float, float, float, float, float, float, float)public Matrix4f lookAtPerspective(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ, Matrix4f dest)
-z with center - eye and store the result in dest.
This method assumes this to be a perspective transformation, obtained via
frustum() or perspective() or
one of their overloads.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAt().
lookAtPerspective in interface Matrix4fceyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectordest - will hold the resultsetLookAt(float, float, float, float, float, float, float, float, float)public Matrix4f lookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
-z with center - eye.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAt().
eyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorlookAt(Vector3fc, Vector3fc, Vector3fc),
setLookAt(float, float, float, float, float, float, float, float, float)public Matrix4f setLookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up)
+z with center - eye.
In order to not make use of vectors to specify eye, center and up but use primitives,
like in the GLU function, use setLookAtLH()
instead.
In order to apply the lookat transformation to a previous existing transformation,
use lookAt().
eye - the position of the cameracenter - the point in space to look atup - the direction of 'up'setLookAtLH(float, float, float, float, float, float, float, float, float),
lookAtLH(Vector3fc, Vector3fc, Vector3fc)public Matrix4f setLookAtLH(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
+z with center - eye.
In order to apply the lookat transformation to a previous existing transformation,
use lookAtLH.
eyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorsetLookAtLH(Vector3fc, Vector3fc, Vector3fc),
lookAtLH(float, float, float, float, float, float, float, float, float)public Matrix4f lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up, Matrix4f dest)
+z with center - eye and store the result in dest.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAtLH(Vector3fc, Vector3fc, Vector3fc).
lookAtLH in interface Matrix4fceye - the position of the cameracenter - the point in space to look atup - the direction of 'up'dest - will hold the resultlookAtLH(float, float, float, float, float, float, float, float, float)public Matrix4f lookAtLH(Vector3fc eye, Vector3fc center, Vector3fc up)
+z with center - eye.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAtLH(Vector3fc, Vector3fc, Vector3fc).
eye - the position of the cameracenter - the point in space to look atup - the direction of 'up'lookAtLH(float, float, float, float, float, float, float, float, float)public Matrix4f lookAtLH(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ, Matrix4f dest)
+z with center - eye and store the result in dest.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAtLH().
lookAtLH in interface Matrix4fceyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectordest - will hold the resultlookAtLH(Vector3fc, Vector3fc, Vector3fc),
setLookAtLH(float, float, float, float, float, float, float, float, float)public Matrix4f lookAtLH(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
+z with center - eye.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAtLH().
eyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorlookAtLH(Vector3fc, Vector3fc, Vector3fc),
setLookAtLH(float, float, float, float, float, float, float, float, float)public Matrix4f lookAtPerspectiveLH(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ, Matrix4f dest)
+z with center - eye and store the result in dest.
This method assumes this to be a perspective transformation, obtained via
frustumLH() or perspectiveLH() or
one of their overloads.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a lookat transformation without post-multiplying it,
use setLookAtLH().
lookAtPerspectiveLH in interface Matrix4fceyeX - the x-coordinate of the eye/camera locationeyeY - the y-coordinate of the eye/camera locationeyeZ - the z-coordinate of the eye/camera locationcenterX - the x-coordinate of the point to look atcenterY - the y-coordinate of the point to look atcenterZ - the z-coordinate of the point to look atupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectordest - will hold the resultsetLookAtLH(float, float, float, float, float, float, float, float, float)public Matrix4f perspective(float fovy, float aspect, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspective.
perspective in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultzZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspective(float, float, float, float, boolean)public Matrix4f perspective(float fovy, float aspect, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspective.
perspective in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultsetPerspective(float, float, float, float)public Matrix4f perspective(float fovy, float aspect, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspective.
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspective(float, float, float, float, boolean)public Matrix4f perspective(float fovy, float aspect, float zNear, float zFar)
[-1..+1] to this matrix.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspective.
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.setPerspective(float, float, float, float)public Matrix4f perspectiveRect(float width, float height, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveRect.
perspectiveRect in interface Matrix4fcwidth - the width of the near frustum planeheight - the height of the near frustum planezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultzZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspectiveRect(float, float, float, float, boolean)public Matrix4f perspectiveRect(float width, float height, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveRect.
perspectiveRect in interface Matrix4fcwidth - the width of the near frustum planeheight - the height of the near frustum planezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultsetPerspectiveRect(float, float, float, float)public Matrix4f perspectiveRect(float width, float height, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveRect.
perspectiveRect in interface Matrix4fcwidth - the width of the near frustum planeheight - the height of the near frustum planezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspectiveRect(float, float, float, float, boolean)public Matrix4f perspectiveRect(float width, float height, float zNear, float zFar)
[-1..+1] to this matrix.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveRect.
perspectiveRect in interface Matrix4fcwidth - the width of the near frustum planeheight - the height of the near frustum planezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.setPerspectiveRect(float, float, float, float)public Matrix4f perspectiveOffCenter(float fovy, float offAngleX, float offAngleY, float aspect, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
The given angles offAngleX and offAngleY 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 offAngleY
is just fovy/2 then the projection frustum is rotated towards +Y and the bottom frustum plane
is parallel to the XZ-plane.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveOffCenter.
perspectiveOffCenter in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)offAngleX - the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planesoffAngleY - the vertical angle between the line of sight and the line crossing the center of the near and far frustum planesaspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultzZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspectiveOffCenter(float, float, float, float, float, float, boolean)public Matrix4f perspectiveOffCenter(float fovy, float offAngleX, float offAngleY, float aspect, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
The given angles offAngleX and offAngleY 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 offAngleY
is just fovy/2 then the projection frustum is rotated towards +Y and the bottom frustum plane
is parallel to the XZ-plane.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveOffCenter.
perspectiveOffCenter in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)offAngleX - the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planesoffAngleY - the vertical angle between the line of sight and the line crossing the center of the near and far frustum planesaspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultsetPerspectiveOffCenter(float, float, float, float, float, float)public Matrix4f perspectiveOffCenter(float fovy, float offAngleX, float offAngleY, float aspect, float zNear, float zFar, boolean zZeroToOne)
The given angles offAngleX and offAngleY 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 offAngleY
is just fovy/2 then the projection frustum is rotated towards +Y and the bottom frustum plane
is parallel to the XZ-plane.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveOffCenter.
perspectiveOffCenter in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)offAngleX - the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planesoffAngleY - the vertical angle between the line of sight and the line crossing the center of the near and far frustum planesaspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspectiveOffCenter(float, float, float, float, float, float, boolean)public Matrix4f perspectiveOffCenter(float fovy, float offAngleX, float offAngleY, float aspect, float zNear, float zFar)
[-1..+1] to this matrix.
The given angles offAngleX and offAngleY 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 offAngleY
is just fovy/2 then the projection frustum is rotated towards +Y and the bottom frustum plane
is parallel to the XZ-plane.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveOffCenter.
perspectiveOffCenter in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)offAngleX - the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planesoffAngleY - the vertical angle between the line of sight and the line crossing the center of the near and far frustum planesaspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.setPerspectiveOffCenter(float, float, float, float, float, float)public Matrix4f setPerspective(float fovy, float aspect, float zNear, float zFar, boolean zZeroToOne)
In order to apply the perspective projection transformation to an existing transformation,
use perspective().
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseperspective(float, float, float, float, boolean)public Matrix4f setPerspective(float fovy, float aspect, float zNear, float zFar)
[-1..+1].
In order to apply the perspective projection transformation to an existing transformation,
use perspective().
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.perspective(float, float, float, float)public Matrix4f setPerspectiveRect(float width, float height, float zNear, float zFar, boolean zZeroToOne)
In order to apply the perspective projection transformation to an existing transformation,
use perspectiveRect().
width - the width of the near frustum planeheight - the height of the near frustum planezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseperspectiveRect(float, float, float, float, boolean)public Matrix4f setPerspectiveRect(float width, float height, float zNear, float zFar)
[-1..+1].
In order to apply the perspective projection transformation to an existing transformation,
use perspectiveRect().
width - the width of the near frustum planeheight - the height of the near frustum planezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.perspectiveRect(float, float, float, float)public Matrix4f setPerspectiveOffCenter(float fovy, float offAngleX, float offAngleY, float aspect, float zNear, float zFar)
[-1..+1].
The given angles offAngleX and offAngleY 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 offAngleY
is just fovy/2 then the projection frustum is rotated towards +Y and the bottom frustum plane
is parallel to the XZ-plane.
In order to apply the perspective projection transformation to an existing transformation,
use perspectiveOffCenter().
fovy - the vertical field of view in radians (must be greater than zero and less than PI)offAngleX - the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planesoffAngleY - the vertical angle between the line of sight and the line crossing the center of the near and far frustum planesaspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.perspectiveOffCenter(float, float, float, float, float, float)public Matrix4f setPerspectiveOffCenter(float fovy, float offAngleX, float offAngleY, float aspect, float zNear, float zFar, boolean zZeroToOne)
The given angles offAngleX and offAngleY 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 offAngleY
is just fovy/2 then the projection frustum is rotated towards +Y and the bottom frustum plane
is parallel to the XZ-plane.
In order to apply the perspective projection transformation to an existing transformation,
use perspectiveOffCenter().
fovy - the vertical field of view in radians (must be greater than zero and less than PI)offAngleX - the horizontal angle between the line of sight and the line crossing the center of the near and far frustum planesoffAngleY - the vertical angle between the line of sight and the line crossing the center of the near and far frustum planesaspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseperspectiveOffCenter(float, float, float, float, float, float)public Matrix4f perspectiveLH(float fovy, float aspect, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveLH.
perspectiveLH in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsedest - will hold the resultsetPerspectiveLH(float, float, float, float, boolean)public Matrix4f perspectiveLH(float fovy, float aspect, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveLH.
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetPerspectiveLH(float, float, float, float, boolean)public Matrix4f perspectiveLH(float fovy, float aspect, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveLH.
perspectiveLH in interface Matrix4fcfovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultsetPerspectiveLH(float, float, float, float)public Matrix4f perspectiveLH(float fovy, float aspect, float zNear, float zFar)
[-1..+1] to this matrix.
If M is this matrix and P the perspective projection matrix,
then the new matrix will be M * P. So when transforming a
vector v with the new matrix by using M * P * v,
the perspective projection will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setPerspectiveLH.
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.setPerspectiveLH(float, float, float, float)public Matrix4f setPerspectiveLH(float fovy, float aspect, float zNear, float zFar, boolean zZeroToOne)
[-1..+1].
In order to apply the perspective projection transformation to an existing transformation,
use perspectiveLH().
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseperspectiveLH(float, float, float, float, boolean)public Matrix4f setPerspectiveLH(float fovy, float aspect, float zNear, float zFar)
[-1..+1].
In order to apply the perspective projection transformation to an existing transformation,
use perspectiveLH().
fovy - the vertical field of view in radians (must be greater than zero and less than PI)aspect - the aspect ratio (i.e. width / height; must be greater than zero)zNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.perspectiveLH(float, float, float, float)public Matrix4f frustum(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustum().
Reference: http://www.songho.ca
frustum in interface Matrix4fcleft - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsedest - will hold the resultsetFrustum(float, float, float, float, float, float, boolean)public Matrix4f frustum(float left, float right, float bottom, float top, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustum().
Reference: http://www.songho.ca
frustum in interface Matrix4fcleft - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultsetFrustum(float, float, float, float, float, float)public Matrix4f frustum(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustum().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetFrustum(float, float, float, float, float, float, boolean)public Matrix4f frustum(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1] to this matrix.
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustum().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.setFrustum(float, float, float, float, float, float)public Matrix4f setFrustum(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
In order to apply the perspective frustum transformation to an existing transformation,
use frustum().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsefrustum(float, float, float, float, float, float, boolean)public Matrix4f setFrustum(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1].
In order to apply the perspective frustum transformation to an existing transformation,
use frustum().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.frustum(float, float, float, float, float, float)public Matrix4f frustumLH(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne, Matrix4f dest)
dest.
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustumLH().
Reference: http://www.songho.ca
frustumLH in interface Matrix4fcleft - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsedest - will hold the resultsetFrustumLH(float, float, float, float, float, float, boolean)public Matrix4f frustumLH(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustumLH().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsesetFrustumLH(float, float, float, float, float, float, boolean)public Matrix4f frustumLH(float left, float right, float bottom, float top, float zNear, float zFar, Matrix4f dest)
[-1..+1] to this matrix and store the result in dest.
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustumLH().
Reference: http://www.songho.ca
frustumLH in interface Matrix4fcleft - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.dest - will hold the resultsetFrustumLH(float, float, float, float, float, float)public Matrix4f frustumLH(float left, float right, float bottom, float top, float zNear, float zFar)
If M is this matrix and F the frustum matrix,
then the new matrix will be M * F. So when transforming a
vector v with the new matrix by using M * F * v,
the frustum transformation will be applied first!
In order to set the matrix to a perspective frustum transformation without post-multiplying,
use setFrustumLH().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.setFrustumLH(float, float, float, float, float, float)public Matrix4f setFrustumLH(float left, float right, float bottom, float top, float zNear, float zFar, boolean zZeroToOne)
[-1..+1].
In order to apply the perspective frustum transformation to an existing transformation,
use frustumLH().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.zZeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falsefrustumLH(float, float, float, float, float, float, boolean)public Matrix4f setFrustumLH(float left, float right, float bottom, float top, float zNear, float zFar)
[-1..+1].
In order to apply the perspective frustum transformation to an existing transformation,
use frustumLH().
Reference: http://www.songho.ca
left - the distance along the x-axis to the left frustum edgeright - the distance along the x-axis to the right frustum edgebottom - the distance along the y-axis to the bottom frustum edgetop - the distance along the y-axis to the top frustum edgezNear - near clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the near clipping plane will be at positive infinity.
In that case, zFar may not also be Float.POSITIVE_INFINITY.zFar - far clipping plane distance. If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
In that case, zNear may not also be Float.POSITIVE_INFINITY.frustumLH(float, float, float, float, float, float)public Matrix4f setFromIntrinsic(float alphaX, float alphaY, float gamma, float u0, float v0, int imgWidth, int imgHeight, float near, float far)
[-1..+1].
See: https://en.wikipedia.org/
Reference: http://ksimek.github.io/
alphaX - specifies the focal length and scale along the X axisalphaY - specifies the focal length and scale along the Y axisgamma - the skew coefficient between the X and Y axis (may be 0)u0 - the X coordinate of the principal point in image/sensor unitsv0 - the Y coordinate of the principal point in image/sensor unitsimgWidth - the width of the sensor/image image/sensor unitsimgHeight - the height of the sensor/image image/sensor unitsnear - the distance to the near planefar - the distance to the far planepublic Matrix4f rotate(Quaternionfc quat, Matrix4f dest)
Quaternionfc to this matrix and store
the result in dest.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
rotate in interface Matrix4fcquat - the Quaternionfcdest - will hold the resultrotation(Quaternionfc)public Matrix4f rotate(Quaternionfc quat)
Quaternionfc to this matrix.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
quat - the Quaternionfcrotation(Quaternionfc)public Matrix4f rotateAffine(Quaternionfc quat, Matrix4f dest)
Quaternionfc to this affine matrix and store
the result in dest.
This method assumes this to be affine.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
rotateAffine in interface Matrix4fcquat - the Quaternionfcdest - will hold the resultrotation(Quaternionfc)public Matrix4f rotateAffine(Quaternionfc quat)
Quaternionfc to this matrix.
This method assumes this to be affine.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
quat - the Quaternionfcrotation(Quaternionfc)public Matrix4f rotateTranslation(Quaternionfc quat, Matrix4f dest)
Quaternionfc to this matrix, which is assumed to only contain a translation, and store
the result in dest.
This method assumes this to only contain a translation.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
rotateTranslation in interface Matrix4fcquat - the Quaternionfcdest - will hold the resultrotation(Quaternionfc)public Matrix4f rotateAround(Quaternionfc quat, float ox, float oy, float oz)
Quaternionfc to this matrix while using (ox, oy, oz) as the rotation origin.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
This method is equivalent to calling: translate(ox, oy, oz).rotate(quat).translate(-ox, -oy, -oz)
Reference: http://en.wikipedia.org
quat - the Quaternionfcox - the x coordinate of the rotation originoy - the y coordinate of the rotation originoz - the z coordinate of the rotation originpublic Matrix4f rotateAroundAffine(Quaternionfc quat, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcQuaternionfc to this affine
matrix while using (ox, oy, oz) as the rotation origin, and store the result in dest.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
This method is only applicable if this is an affine matrix.
This method is equivalent to calling: translate(ox, oy, oz, dest).rotate(quat).translate(-ox, -oy, -oz)
Reference: http://en.wikipedia.org
rotateAroundAffine in interface Matrix4fcquat - the Quaternionfcox - the x coordinate of the rotation originoy - the y coordinate of the rotation originoz - the z coordinate of the rotation origindest - will hold the resultpublic Matrix4f rotateAround(Quaternionfc quat, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcQuaternionfc to this matrix while using (ox, oy, oz) as the rotation origin,
and store the result in dest.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be M * Q. So when transforming a
vector v with the new matrix by using M * Q * v,
the quaternion rotation will be applied first!
This method is equivalent to calling: translate(ox, oy, oz, dest).rotate(quat).translate(-ox, -oy, -oz)
Reference: http://en.wikipedia.org
rotateAround in interface Matrix4fcquat - the Quaternionfcox - the x coordinate of the rotation originoy - the y coordinate of the rotation originoz - the z coordinate of the rotation origindest - will hold the resultpublic Matrix4f rotationAround(Quaternionfc quat, float ox, float oy, float oz)
Quaternionfc while using (ox, oy, oz) as the rotation origin.
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.
This method is equivalent to calling: translation(ox, oy, oz).rotate(quat).translate(-ox, -oy, -oz)
Reference: http://en.wikipedia.org
quat - the Quaternionfcox - the x coordinate of the rotation originoy - the y coordinate of the rotation originoz - the z coordinate of the rotation originpublic Matrix4f rotateLocal(Quaternionfc quat, Matrix4f dest)
Quaternionfc to this matrix and store
the result in dest.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be Q * M. So when transforming a
vector v with the new matrix by using Q * M * v,
the quaternion rotation will be applied last!
In order to set the matrix to a rotation transformation without pre-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
rotateLocal in interface Matrix4fcquat - the Quaternionfcdest - will hold the resultrotation(Quaternionfc)public Matrix4f rotateLocal(Quaternionfc quat)
Quaternionfc to this matrix.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be Q * M. So when transforming a
vector v with the new matrix by using Q * M * v,
the quaternion rotation will be applied last!
In order to set the matrix to a rotation transformation without pre-multiplying,
use rotation(Quaternionfc).
Reference: http://en.wikipedia.org
quat - the Quaternionfcrotation(Quaternionfc)public Matrix4f rotateAroundLocal(Quaternionfc quat, float ox, float oy, float oz, Matrix4f dest)
Matrix4fcQuaternionfc to this matrix while using (ox, oy, oz)
as the rotation origin, and store the result in dest.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be Q * M. So when transforming a
vector v with the new matrix by using Q * M * v,
the quaternion rotation will be applied last!
This method is equivalent to calling: translateLocal(-ox, -oy, -oz, dest).rotateLocal(quat).translateLocal(ox, oy, oz)
Reference: http://en.wikipedia.org
rotateAroundLocal in interface Matrix4fcquat - the Quaternionfcox - the x coordinate of the rotation originoy - the y coordinate of the rotation originoz - the z coordinate of the rotation origindest - will hold the resultpublic Matrix4f rotateAroundLocal(Quaternionfc quat, float ox, float oy, float oz)
Quaternionfc to this matrix while using (ox, oy, oz)
as the rotation origin.
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.
If M is this matrix and Q the rotation matrix obtained from the given quaternion,
then the new matrix will be Q * M. So when transforming a
vector v with the new matrix by using Q * M * v,
the quaternion rotation will be applied last!
This method is equivalent to calling: translateLocal(-ox, -oy, -oz).rotateLocal(quat).translateLocal(ox, oy, oz)
Reference: http://en.wikipedia.org
quat - the Quaternionfcox - the x coordinate of the rotation originoy - the y coordinate of the rotation originoz - the z coordinate of the rotation originpublic Matrix4f rotate(AxisAngle4f axisAngle)
AxisAngle4f, to this matrix.
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.
If M is this matrix and A the rotation matrix obtained from the given AxisAngle4f,
then the new matrix will be M * A. So when transforming a
vector v with the new matrix by using M * A * v,
the AxisAngle4f rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(AxisAngle4f).
Reference: http://en.wikipedia.org
axisAngle - the AxisAngle4f (needs to be normalized)rotate(float, float, float, float),
rotation(AxisAngle4f)public Matrix4f rotate(AxisAngle4f axisAngle, Matrix4f dest)
AxisAngle4f and store the result in dest.
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.
If M is this matrix and A the rotation matrix obtained from the given AxisAngle4f,
then the new matrix will be M * A. So when transforming a
vector v with the new matrix by using M * A * v,
the AxisAngle4f rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(AxisAngle4f).
Reference: http://en.wikipedia.org
rotate in interface Matrix4fcaxisAngle - the AxisAngle4f (needs to be normalized)dest - will hold the resultrotate(float, float, float, float),
rotation(AxisAngle4f)public Matrix4f rotate(float angle, Vector3fc axis)
The axis described by the axis vector needs to be a unit vector.
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.
If M is this matrix and A the rotation matrix obtained from the given axis-angle,
then the new matrix will be M * A. So when transforming a
vector v with the new matrix by using M * A * v,
the axis-angle rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(float, Vector3fc).
Reference: http://en.wikipedia.org
angle - the angle in radiansaxis - the rotation axis (needs to be normalized)rotate(float, float, float, float),
rotation(float, Vector3fc)public Matrix4f rotate(float angle, Vector3fc axis, Matrix4f dest)
dest.
The axis described by the axis vector needs to be a unit vector.
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.
If M is this matrix and A the rotation matrix obtained from the given axis-angle,
then the new matrix will be M * A. So when transforming a
vector v with the new matrix by using M * A * v,
the axis-angle rotation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying,
use rotation(float, Vector3fc).
Reference: http://en.wikipedia.org
rotate in interface Matrix4fcangle - the angle in radiansaxis - the rotation axis (needs to be normalized)dest - will hold the resultrotate(float, float, float, float),
rotation(float, Vector3fc)public Vector4f unproject(float winX, float winY, float winZ, int[] viewport, Vector4f dest)
Matrix4fc(winX, winY, winZ) by this matrix using the specified viewport.
This method first converts the given window coordinates to normalized device coordinates in the range [-1..1]
and then transforms those NDC coordinates by the inverse of this matrix.
The depth range of winZ is assumed to be [0..1], which is also the OpenGL default.
As a necessary computation step for unprojecting, this method computes the inverse of this matrix.
In order to avoid computing the matrix inverse with every invocation, the inverse of this matrix can be built
once outside using Matrix4fc.invert(Matrix4f) and then the method unprojectInv() can be invoked on it.
unproject in interface Matrix4fcwinX - the x-coordinate in window coordinates (pixels)winY - the y-coordinate in window coordinates (pixels)winZ - the z-coordinate, which is the depth value in [0..1]viewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unprojectInv(float, float, float, int[], Vector4f),
Matrix4fc.invert(Matrix4f)public Vector3f unproject(float winX, float winY, float winZ, int[] viewport, Vector3f dest)
Matrix4fc(winX, winY, winZ) by this matrix using the specified viewport.
This method first converts the given window coordinates to normalized device coordinates in the range [-1..1]
and then transforms those NDC coordinates by the inverse of this matrix.
The depth range of winZ is assumed to be [0..1], which is also the OpenGL default.
As a necessary computation step for unprojecting, this method computes the inverse of this matrix.
In order to avoid computing the matrix inverse with every invocation, the inverse of this matrix can be built
once outside using Matrix4fc.invert(Matrix4f) and then the method unprojectInv() can be invoked on it.
unproject in interface Matrix4fcwinX - the x-coordinate in window coordinates (pixels)winY - the y-coordinate in window coordinates (pixels)winZ - the z-coordinate, which is the depth value in [0..1]viewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unprojectInv(float, float, float, int[], Vector3f),
Matrix4fc.invert(Matrix4f)public Vector4f unproject(Vector3fc winCoords, int[] viewport, Vector4f dest)
Matrix4fcwinCoords by this matrix using the specified viewport.
This method first converts the given window coordinates to normalized device coordinates in the range [-1..1]
and then transforms those NDC coordinates by the inverse of this matrix.
The depth range of winCoords.z is assumed to be [0..1], which is also the OpenGL default.
As a necessary computation step for unprojecting, this method computes the inverse of this matrix.
In order to avoid computing the matrix inverse with every invocation, the inverse of this matrix can be built
once outside using Matrix4fc.invert(Matrix4f) and then the method unprojectInv() can be invoked on it.
unproject in interface Matrix4fcwinCoords - the window coordinates to unprojectviewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unprojectInv(float, float, float, int[], Vector4f),
Matrix4fc.unproject(float, float, float, int[], Vector4f),
Matrix4fc.invert(Matrix4f)public Vector3f unproject(Vector3fc winCoords, int[] viewport, Vector3f dest)
Matrix4fcwinCoords by this matrix using the specified viewport.
This method first converts the given window coordinates to normalized device coordinates in the range [-1..1]
and then transforms those NDC coordinates by the inverse of this matrix.
The depth range of winCoords.z is assumed to be [0..1], which is also the OpenGL default.
As a necessary computation step for unprojecting, this method computes the inverse of this matrix.
In order to avoid computing the matrix inverse with every invocation, the inverse of this matrix can be built
once outside using Matrix4fc.invert(Matrix4f) and then the method unprojectInv() can be invoked on it.
unproject in interface Matrix4fcwinCoords - the window coordinates to unprojectviewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unprojectInv(float, float, float, int[], Vector3f),
Matrix4fc.unproject(float, float, float, int[], Vector3f),
Matrix4fc.invert(Matrix4f)public Matrix4f unprojectRay(float winX, float winY, int[] viewport, Vector3f originDest, Vector3f dirDest)
Matrix4fc(winX, winY) by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0.
This method first converts the given window coordinates to normalized device coordinates in the range [-1..1]
and then transforms those NDC coordinates by the inverse of this matrix.
As a necessary computation step for unprojecting, this method computes the inverse of this matrix.
In order to avoid computing the matrix inverse with every invocation, the inverse of this matrix can be built
once outside using Matrix4fc.invert(Matrix4f) and then the method unprojectInvRay() can be invoked on it.
unprojectRay in interface Matrix4fcwinX - the x-coordinate in window coordinates (pixels)winY - the y-coordinate in window coordinates (pixels)viewport - the viewport described by [x, y, width, height]originDest - will hold the ray origindirDest - will hold the (unnormalized) ray directionMatrix4fc.unprojectInvRay(float, float, int[], Vector3f, Vector3f),
Matrix4fc.invert(Matrix4f)public Matrix4f unprojectRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest)
Matrix4fcwinCoords by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0.
This method first converts the given window coordinates to normalized device coordinates in the range [-1..1]
and then transforms those NDC coordinates by the inverse of this matrix.
As a necessary computation step for unprojecting, this method computes the inverse of this matrix.
In order to avoid computing the matrix inverse with every invocation, the inverse of this matrix can be built
once outside using Matrix4fc.invert(Matrix4f) and then the method unprojectInvRay() can be invoked on it.
unprojectRay in interface Matrix4fcwinCoords - the window coordinates to unprojectviewport - the viewport described by [x, y, width, height]originDest - will hold the ray origindirDest - will hold the (unnormalized) ray directionMatrix4fc.unprojectInvRay(float, float, int[], Vector3f, Vector3f),
Matrix4fc.unprojectRay(float, float, int[], Vector3f, Vector3f),
Matrix4fc.invert(Matrix4f)public Vector4f unprojectInv(Vector3fc winCoords, int[] viewport, Vector4f dest)
Matrix4fcwinCoords by this matrix using the specified viewport.
This method differs from unproject()
in that it assumes that this is already the inverse matrix of the original projection matrix.
It exists to avoid recomputing the matrix inverse with every invocation.
The depth range of winCoords.z is assumed to be [0..1], which is also the OpenGL default.
This method reads the four viewport parameters from the given int[].
unprojectInv in interface Matrix4fcwinCoords - the window coordinates to unprojectviewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unproject(Vector3fc, int[], Vector4f)public Vector4f unprojectInv(float winX, float winY, float winZ, int[] viewport, Vector4f dest)
Matrix4fc(winX, winY, winZ) by this matrix using the specified viewport.
This method differs from unproject()
in that it assumes that this is already the inverse matrix of the original projection matrix.
It exists to avoid recomputing the matrix inverse with every invocation.
The depth range of winZ is assumed to be [0..1], which is also the OpenGL default.
unprojectInv in interface Matrix4fcwinX - the x-coordinate in window coordinates (pixels)winY - the y-coordinate in window coordinates (pixels)winZ - the z-coordinate, which is the depth value in [0..1]viewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unproject(float, float, float, int[], Vector4f)public Matrix4f unprojectInvRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest)
Matrix4fcwinCoords by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0.
This method differs from unprojectRay()
in that it assumes that this is already the inverse matrix of the original projection matrix.
It exists to avoid recomputing the matrix inverse with every invocation.
unprojectInvRay in interface Matrix4fcwinCoords - the window coordinates to unprojectviewport - the viewport described by [x, y, width, height]originDest - will hold the ray origindirDest - will hold the (unnormalized) ray directionMatrix4fc.unprojectRay(Vector2fc, int[], Vector3f, Vector3f)public Matrix4f unprojectInvRay(float winX, float winY, int[] viewport, Vector3f originDest, Vector3f dirDest)
Matrix4fc(winX, winY) by this matrix using the specified viewport
and compute the origin and the direction of the resulting ray which starts at NDC z = -1.0 and goes through NDC z = +1.0.
This method differs from unprojectRay()
in that it assumes that this is already the inverse matrix of the original projection matrix.
It exists to avoid recomputing the matrix inverse with every invocation.
unprojectInvRay in interface Matrix4fcwinX - the x-coordinate in window coordinates (pixels)winY - the y-coordinate in window coordinates (pixels)viewport - the viewport described by [x, y, width, height]originDest - will hold the ray origindirDest - will hold the (unnormalized) ray directionMatrix4fc.unprojectRay(float, float, int[], Vector3f, Vector3f)public Vector3f unprojectInv(Vector3fc winCoords, int[] viewport, Vector3f dest)
Matrix4fcwinCoords by this matrix using the specified viewport.
This method differs from unproject()
in that it assumes that this is already the inverse matrix of the original projection matrix.
It exists to avoid recomputing the matrix inverse with every invocation.
The depth range of winCoords.z is assumed to be [0..1], which is also the OpenGL default.
unprojectInv in interface Matrix4fcwinCoords - the window coordinates to unprojectviewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unproject(Vector3fc, int[], Vector3f)public Vector3f unprojectInv(float winX, float winY, float winZ, int[] viewport, Vector3f dest)
Matrix4fc(winX, winY, winZ) by this matrix using the specified viewport.
This method differs from unproject()
in that it assumes that this is already the inverse matrix of the original projection matrix.
It exists to avoid recomputing the matrix inverse with every invocation.
The depth range of winZ is assumed to be [0..1], which is also the OpenGL default.
unprojectInv in interface Matrix4fcwinX - the x-coordinate in window coordinates (pixels)winY - the y-coordinate in window coordinates (pixels)winZ - the z-coordinate, which is the depth value in [0..1]viewport - the viewport described by [x, y, width, height]dest - will hold the unprojected positionMatrix4fc.unproject(float, float, float, int[], Vector3f)public Vector4f project(float x, float y, float z, int[] viewport, Vector4f winCoordsDest)
Matrix4fc(x, y, z) position via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest.
This method transforms the given coordinates by this matrix including perspective division to
obtain normalized device coordinates, and then translates these into window coordinates by using the
given viewport settings [x, y, width, height].
The depth range of the returned winCoordsDest.z will be [0..1], which is also the OpenGL default.
project in interface Matrix4fcx - the x-coordinate of the position to projecty - the y-coordinate of the position to projectz - the z-coordinate of the position to projectviewport - the viewport described by [x, y, width, height]winCoordsDest - will hold the projected window coordinatespublic Vector3f project(float x, float y, float z, int[] viewport, Vector3f winCoordsDest)
Matrix4fc(x, y, z) position via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest.
This method transforms the given coordinates by this matrix including perspective division to
obtain normalized device coordinates, and then translates these into window coordinates by using the
given viewport settings [x, y, width, height].
The depth range of the returned winCoordsDest.z will be [0..1], which is also the OpenGL default.
project in interface Matrix4fcx - the x-coordinate of the position to projecty - the y-coordinate of the position to projectz - the z-coordinate of the position to projectviewport - the viewport described by [x, y, width, height]winCoordsDest - will hold the projected window coordinatespublic Vector4f project(Vector3fc position, int[] viewport, Vector4f winCoordsDest)
Matrix4fcposition via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest.
This method transforms the given coordinates by this matrix including perspective division to
obtain normalized device coordinates, and then translates these into window coordinates by using the
given viewport settings [x, y, width, height].
The depth range of the returned winCoordsDest.z will be [0..1], which is also the OpenGL default.
project in interface Matrix4fcposition - the position to project into window coordinatesviewport - the viewport described by [x, y, width, height]winCoordsDest - will hold the projected window coordinatesMatrix4fc.project(float, float, float, int[], Vector4f)public Vector3f project(Vector3fc position, int[] viewport, Vector3f winCoordsDest)
Matrix4fcposition via this matrix using the specified viewport
and store the resulting window coordinates in winCoordsDest.
This method transforms the given coordinates by this matrix including perspective division to
obtain normalized device coordinates, and then translates these into window coordinates by using the
given viewport settings [x, y, width, height].
The depth range of the returned winCoordsDest.z will be [0..1], which is also the OpenGL default.
project in interface Matrix4fcposition - the position to project into window coordinatesviewport - the viewport described by [x, y, width, height]winCoordsDest - will hold the projected window coordinatesMatrix4fc.project(float, float, float, int[], Vector4f)public Matrix4f reflect(float a, float b, float c, float d, Matrix4f dest)
Matrix4fcx*a + y*b + z*c + d = 0 and store the result in dest.
The vector (a, b, c) must be a unit vector.
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
Reference: msdn.microsoft.com
public Matrix4f reflect(float a, float b, float c, float d)
x*a + y*b + z*c + d = 0.
The vector (a, b, c) must be a unit vector.
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
Reference: msdn.microsoft.com
a - the x factor in the plane equationb - the y factor in the plane equationc - the z factor in the plane equationd - the constant in the plane equationpublic Matrix4f reflect(float nx, float ny, float nz, float px, float py, float pz)
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
nx - the x-coordinate of the plane normalny - the y-coordinate of the plane normalnz - the z-coordinate of the plane normalpx - the x-coordinate of a point on the planepy - the y-coordinate of a point on the planepz - the z-coordinate of a point on the planepublic Matrix4f reflect(float nx, float ny, float nz, float px, float py, float pz, Matrix4f dest)
Matrix4fcdest.
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
reflect in interface Matrix4fcnx - the x-coordinate of the plane normalny - the y-coordinate of the plane normalnz - the z-coordinate of the plane normalpx - the x-coordinate of a point on the planepy - the y-coordinate of a point on the planepz - the z-coordinate of a point on the planedest - will hold the resultpublic Matrix4f reflect(Vector3fc normal, Vector3fc point)
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
normal - the plane normalpoint - a point on the planepublic Matrix4f reflect(Quaternionfc orientation, Vector3fc point)
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 (0, 0, 1). So, if the given Quaternionfc is
the identity (does not apply any additional rotation), the reflection plane will be z=0, offset by the given point.
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
orientation - the plane orientationpoint - a point on the planepublic Matrix4f reflect(Quaternionfc orientation, Vector3fc point, Matrix4f dest)
Matrix4fcdest.
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 (0, 0, 1). So, if the given Quaternionfc is
the identity (does not apply any additional rotation), the reflection plane will be z=0, offset by the given point.
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
public Matrix4f reflect(Vector3fc normal, Vector3fc point, Matrix4f dest)
Matrix4fcdest.
If M is this matrix and R the reflection matrix,
then the new matrix will be M * R. So when transforming a
vector v with the new matrix by using M * R * v, the
reflection will be applied first!
public Matrix4f reflection(float a, float b, float c, float d)
x*a + y*b + z*c + d = 0.
The vector (a, b, c) must be a unit vector.
Reference: msdn.microsoft.com
a - the x factor in the plane equationb - the y factor in the plane equationc - the z factor in the plane equationd - the constant in the plane equationpublic Matrix4f reflection(float nx, float ny, float nz, float px, float py, float pz)
nx - the x-coordinate of the plane normalny - the y-coordinate of the plane normalnz - the z-coordinate of the plane normalpx - the x-coordinate of a point on the planepy - the y-coordinate of a point on the planepz - the z-coordinate of a point on the planepublic Matrix4f reflection(Vector3fc normal, Vector3fc point)
normal - the plane normalpoint - a point on the planepublic Matrix4f reflection(Quaternionfc orientation, Vector3fc point)
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 (0, 0, 1). So, if the given Quaternionfc is
the identity (does not apply any additional rotation), the reflection plane will be z=0, offset by the given point.
orientation - the plane orientationpoint - a point on the planepublic Vector4f getRow(int row, Vector4f dest) throws IndexOutOfBoundsException
Matrix4fcrow index, starting with 0.getRow in interface Matrix4fcrow - the row index in [0..3]dest - will hold the row componentsIndexOutOfBoundsException - if row is not in [0..3]public Vector3f getRow(int row, Vector3f dest) throws IndexOutOfBoundsException
Matrix4fcrow index, starting with 0.getRow in interface Matrix4fcrow - the row index in [0..3]dest - will hold the first three row componentsIndexOutOfBoundsException - if row is not in [0..3]public Matrix4f setRow(int row, Vector4fc src) throws IndexOutOfBoundsException
row index, starting with 0.row - the row index in [0..3]src - the row components to setIndexOutOfBoundsException - if row is not in [0..3]public Vector4f getColumn(int column, Vector4f dest) throws IndexOutOfBoundsException
Matrix4fccolumn index, starting with 0.getColumn in interface Matrix4fccolumn - the column index in [0..3]dest - will hold the column componentsIndexOutOfBoundsException - if column is not in [0..3]public Vector3f getColumn(int column, Vector3f dest) throws IndexOutOfBoundsException
Matrix4fccolumn index, starting with 0.getColumn in interface Matrix4fccolumn - the column index in [0..3]dest - will hold the first three column componentsIndexOutOfBoundsException - if column is not in [0..3]public Matrix4f setColumn(int column, Vector4fc src) throws IndexOutOfBoundsException
column index, starting with 0.column - the column index in [0..3]src - the column components to setIndexOutOfBoundsException - if column is not in [0..3]public Matrix4f normal()
this
and store it into the upper left 3x3 submatrix of this.
All other values of this will be set to identity.
The normal matrix of m is the transpose of the inverse of m.
Please note that, if this is an orthogonal matrix or a matrix whose columns are orthogonal vectors,
then this method need not be invoked, since in that case this itself is its normal matrix.
In that case, use set3x3(Matrix4f) to set a given Matrix4f to only the upper left 3x3 submatrix
of this matrix.
set3x3(Matrix4f)public Matrix4f normal(Matrix4f dest)
this
and store it into the upper left 3x3 submatrix of dest.
All other values of dest will be set to identity.
The normal matrix of m is the transpose of the inverse of m.
Please note that, if this is an orthogonal matrix or a matrix whose columns are orthogonal vectors,
then this method need not be invoked, since in that case this itself is its normal matrix.
In that case, use set3x3(Matrix4f) to set a given Matrix4f to only the upper left 3x3 submatrix
of this matrix.
normal in interface Matrix4fcdest - will hold the resultset3x3(Matrix4f)public Matrix3f normal(Matrix3f dest)
this
and store it into dest.
The normal matrix of m is the transpose of the inverse of m.
Please note that, if this is an orthogonal matrix or a matrix whose columns are orthogonal vectors,
then this method need not be invoked, since in that case this itself is its normal matrix.
In that case, use Matrix3f.set(Matrix4fc) to set a given Matrix3f to only the upper left 3x3 submatrix
of this matrix.
normal in interface Matrix4fcdest - will hold the resultMatrix3f.set(Matrix4fc),
get3x3(Matrix3f)public Matrix4f normalize3x3()
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 skewing).
public Matrix4f normalize3x3(Matrix4f dest)
Matrix4fcdest.
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 skewing).
normalize3x3 in interface Matrix4fcdest - will hold the resultpublic Matrix3f normalize3x3(Matrix3f dest)
Matrix4fcdest.
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 skewing).
normalize3x3 in interface Matrix4fcdest - will hold the resultpublic Vector4f frustumPlane(int plane, Vector4f planeEquation)
Matrix4fcthis matrix, which
can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given planeEquation.
Generally, this method computes the frustum plane in the local frame of
any coordinate system that existed before this
transformation was applied to it in order to yield homogeneous clipping space.
The frustum plane will be given in the form of a general plane equation:
a*x + b*y + c*z + d = 0, where the given Vector4f components will
hold the (a, b, c, d) values of the equation.
The plane normal, which is (a, b, c), is directed "inwards" of the frustum.
Any plane/point test using a*x + b*y + c*z + d therefore will yield a result greater than zero
if the point is within the frustum (i.e. at the positive side of the frustum plane).
For performing frustum culling, the class FrustumIntersection should be used instead of
manually obtaining the frustum planes and testing them against points, spheres or axis-aligned boxes.
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
frustumPlane in interface Matrix4fcplane - one of the six possible planes, given as numeric constants
Matrix4fc.PLANE_NX, Matrix4fc.PLANE_PX,
Matrix4fc.PLANE_NY, Matrix4fc.PLANE_PY,
Matrix4fc.PLANE_NZ and Matrix4fc.PLANE_PZplaneEquation - will hold the computed plane equation.
The plane equation will be normalized, meaning that (a, b, c) will be a unit vectorpublic Planef frustumPlane(int which, Planef plane)
Matrix4fcthis matrix, which
can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given plane.
Generally, this method computes the frustum plane in the local frame of
any coordinate system that existed before this
transformation was applied to it in order to yield homogeneous clipping space.
The plane normal, which is (a, b, c), is directed "inwards" of the frustum.
Any plane/point test using a*x + b*y + c*z + d therefore will yield a result greater than zero
if the point is within the frustum (i.e. at the positive side of the frustum plane).
For performing frustum culling, the class FrustumIntersection should be used instead of
manually obtaining the frustum planes and testing them against points, spheres or axis-aligned boxes.
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
frustumPlane in interface Matrix4fcwhich - one of the six possible planes, given as numeric constants
Matrix4fc.PLANE_NX, Matrix4fc.PLANE_PX,
Matrix4fc.PLANE_NY, Matrix4fc.PLANE_PY,
Matrix4fc.PLANE_NZ and Matrix4fc.PLANE_PZplane - will hold the computed plane equation.
The plane equation will be normalized, meaning that (a, b, c) will be a unit vectorpublic Vector3f frustumCorner(int corner, Vector3f point)
Matrix4fcthis matrix, which
can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given point.
Generally, this method computes the frustum corners in the local frame of
any coordinate system that existed before this
transformation was applied to it in order to yield homogeneous clipping space.
Reference: http://geomalgorithms.com
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
frustumCorner in interface Matrix4fccorner - one of the eight possible corners, given as numeric constants
Matrix4fc.CORNER_NXNYNZ, Matrix4fc.CORNER_PXNYNZ, Matrix4fc.CORNER_PXPYNZ, Matrix4fc.CORNER_NXPYNZ,
Matrix4fc.CORNER_PXNYPZ, Matrix4fc.CORNER_NXNYPZ, Matrix4fc.CORNER_NXPYPZ, Matrix4fc.CORNER_PXPYPZpoint - will hold the resulting corner point coordinatespublic Vector3f perspectiveOrigin(Vector3f origin)
this matrix,
which can be a projection matrix or a combined modelview-projection matrix, and store the result
in the given origin.
Note that this method will only work using perspective projections obtained via one of the
perspective methods, such as perspective()
or frustum().
Generally, this method computes the origin in the local frame of
any coordinate system that existed before this
transformation was applied to it in order to yield homogeneous clipping space.
Reference: http://geomalgorithms.com
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
perspectiveOrigin in interface Matrix4fcorigin - will hold the origin of the coordinate system before applying this
perspective projection transformationpublic float perspectiveFov()
Note that this method will only work using perspective projections obtained via one of the
perspective methods, such as perspective()
or frustum().
For orthogonal transformations this method will return 0.0.
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
perspectiveFov in interface Matrix4fcpublic float perspectiveNear()
this perspective projection matrix.
This method only works if this is a perspective projection matrix, for example obtained via perspective(float, float, float, float).
perspectiveNear in interface Matrix4fcpublic float perspectiveFar()
this perspective projection matrix.
This method only works if this is a perspective projection matrix, for example obtained via perspective(float, float, float, float).
perspectiveFar in interface Matrix4fcpublic Vector3f frustumRayDir(float x, float y, Vector3f dir)
Matrix4fc
This method computes the dir vector in the local frame of
any coordinate system that existed before this
transformation was applied to it in order to yield homogeneous clipping space.
The parameters x and y are used to interpolate the generated ray direction
from the bottom-left to the top-right frustum corners.
For optimal efficiency when building many ray directions over the whole frustum,
it is recommended to use this method only in order to compute the four corner rays at
(0, 0), (1, 0), (0, 1) and (1, 1)
and then bilinearly interpolating between them; or to use the FrustumRayBuilder.
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
frustumRayDir in interface Matrix4fcx - the interpolation factor along the left-to-right frustum planes, within [0..1]y - the interpolation factor along the bottom-to-top frustum planes, within [0..1]dir - will hold the normalized ray direction in the local frame of the coordinate system before
transforming to homogeneous clipping space using this matrixpublic Vector3f positiveZ(Vector3f dir)
Matrix4fc+Z before the transformation represented by this matrix is applied.
This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
that is transformed to +Z by this matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).invert(); inv.transformDirection(dir.set(0, 0, 1)).normalize();If
this is already an orthogonal matrix, then consider using Matrix4fc.normalizedPositiveZ(Vector3f) instead.
Reference: http://www.euclideanspace.com
public Vector3f normalizedPositiveZ(Vector3f dir)
Matrix4fc+Z before the transformation represented by this orthogonal matrix is applied.
This method only produces correct results if this is an orthogonal matrix.
This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
that is transformed to +Z by this matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).transpose(); inv.transformDirection(dir.set(0, 0, 1));
Reference: http://www.euclideanspace.com
normalizedPositiveZ in interface Matrix4fcdir - will hold the direction of +Zpublic Vector3f positiveX(Vector3f dir)
Matrix4fc+X before the transformation represented by this matrix is applied.
This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
that is transformed to +X by this matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).invert(); inv.transformDirection(dir.set(1, 0, 0)).normalize();If
this is already an orthogonal matrix, then consider using Matrix4fc.normalizedPositiveX(Vector3f) instead.
Reference: http://www.euclideanspace.com
public Vector3f normalizedPositiveX(Vector3f dir)
Matrix4fc+X before the transformation represented by this orthogonal matrix is applied.
This method only produces correct results if this is an orthogonal matrix.
This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
that is transformed to +X by this matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).transpose(); inv.transformDirection(dir.set(1, 0, 0));
Reference: http://www.euclideanspace.com
normalizedPositiveX in interface Matrix4fcdir - will hold the direction of +Xpublic Vector3f positiveY(Vector3f dir)
Matrix4fc+Y before the transformation represented by this matrix is applied.
This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
that is transformed to +Y by this matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).invert(); inv.transformDirection(dir.set(0, 1, 0)).normalize();If
this is already an orthogonal matrix, then consider using Matrix4fc.normalizedPositiveY(Vector3f) instead.
Reference: http://www.euclideanspace.com
public Vector3f normalizedPositiveY(Vector3f dir)
Matrix4fc+Y before the transformation represented by this orthogonal matrix is applied.
This method only produces correct results if this is an orthogonal matrix.
This method uses the rotation component of the upper left 3x3 submatrix to obtain the direction
that is transformed to +Y by this matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).transpose(); inv.transformDirection(dir.set(0, 1, 0));
Reference: http://www.euclideanspace.com
normalizedPositiveY in interface Matrix4fcdir - will hold the direction of +Ypublic Vector3f originAffine(Vector3f origin)
Matrix4fcthis affine matrix.
This can be used to get the position of the "camera" from a given view transformation matrix.
This method only works with affine matrices.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).invertAffine(); inv.transformPosition(origin.set(0, 0, 0));
originAffine in interface Matrix4fcorigin - will hold the position transformed to the originpublic Vector3f origin(Vector3f dest)
Matrix4fcthis matrix.
This can be used to get the position of the "camera" from a given view/projection transformation matrix.
This method is equivalent to the following code:
Matrix4f inv = new Matrix4f(this).invert(); inv.transformPosition(origin.set(0, 0, 0));
public Matrix4f shadow(Vector4f light, float a, float b, float c, float d)
x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction light.
If light.w is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
Reference: ftp.sgi.com
light - the light's vectora - the x factor in the plane equationb - the y factor in the plane equationc - the z factor in the plane equationd - the constant in the plane equationpublic Matrix4f shadow(Vector4f light, float a, float b, float c, float d, Matrix4f dest)
Matrix4fcx*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction light
and store the result in dest.
If light.w is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
Reference: ftp.sgi.com
public Matrix4f shadow(float lightX, float lightY, float lightZ, float lightW, float a, float b, float c, float d)
x*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW).
If lightW is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
Reference: ftp.sgi.com
lightX - the x-component of the light's vectorlightY - the y-component of the light's vectorlightZ - the z-component of the light's vectorlightW - the w-component of the light's vectora - the x factor in the plane equationb - the y factor in the plane equationc - the z factor in the plane equationd - the constant in the plane equationpublic Matrix4f shadow(float lightX, float lightY, float lightZ, float lightW, float a, float b, float c, float d, Matrix4f dest)
Matrix4fcx*a + y*b + z*c + d = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW)
and store the result in dest.
If lightW is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
Reference: ftp.sgi.com
shadow in interface Matrix4fclightX - the x-component of the light's vectorlightY - the y-component of the light's vectorlightZ - the z-component of the light's vectorlightW - the w-component of the light's vectora - the x factor in the plane equationb - the y factor in the plane equationc - the z factor in the plane equationd - the constant in the plane equationdest - will hold the resultpublic Matrix4f shadow(Vector4f light, Matrix4fc planeTransform, Matrix4f dest)
Matrix4fcy = 0 as if casting a shadow from a given light position/direction light
and store the result in dest.
Before the shadow projection is applied, the plane is transformed via the specified planeTransformation.
If light.w is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
public Matrix4f shadow(Vector4f light, Matrix4f planeTransform)
y = 0 as if casting a shadow from a given light position/direction light.
Before the shadow projection is applied, the plane is transformed via the specified planeTransformation.
If light.w is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
light - the light's vectorplaneTransform - the transformation to transform the implied plane y = 0 before applying the projectionpublic Matrix4f shadow(float lightX, float lightY, float lightZ, float lightW, Matrix4fc planeTransform, Matrix4f dest)
Matrix4fcy = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW)
and store the result in dest.
Before the shadow projection is applied, the plane is transformed via the specified planeTransformation.
If lightW is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
shadow in interface Matrix4fclightX - the x-component of the light vectorlightY - the y-component of the light vectorlightZ - the z-component of the light vectorlightW - the w-component of the light vectorplaneTransform - the transformation to transform the implied plane y = 0 before applying the projectiondest - will hold the resultpublic Matrix4f shadow(float lightX, float lightY, float lightZ, float lightW, Matrix4f planeTransform)
y = 0 as if casting a shadow from a given light position/direction (lightX, lightY, lightZ, lightW).
Before the shadow projection is applied, the plane is transformed via the specified planeTransformation.
If lightW is 0.0 the light is being treated as a directional light; if it is 1.0 it is a point light.
If M is this matrix and S the shadow matrix,
then the new matrix will be M * S. So when transforming a
vector v with the new matrix by using M * S * v, the
reflection will be applied first!
lightX - the x-component of the light vectorlightY - the y-component of the light vectorlightZ - the z-component of the light vectorlightW - the w-component of the light vectorplaneTransform - the transformation to transform the implied plane y = 0 before applying the projectionpublic Matrix4f billboardCylindrical(Vector3fc objPos, Vector3fc targetPos, Vector3fc up)
objPos towards
a target position at targetPos while constraining a cylindrical rotation around the given up vector.
This method can be used to create the complete model transformation for a given object, including the translation of the object to
its position objPos.
objPos - the position of the object to rotate towards targetPostargetPos - the position of the target (for example the camera) towards which to rotate the objectup - the rotation axis (must be normalized)public Matrix4f billboardSpherical(Vector3fc objPos, Vector3fc targetPos, Vector3fc up)
objPos towards
a target position at targetPos.
This method can be used to create the complete model transformation for a given object, including the translation of the object to
its position objPos.
If preserving an up vector is not necessary when rotating the +Z axis, then a shortest arc rotation can be obtained
using billboardSpherical(Vector3fc, Vector3fc).
objPos - the position of the object to rotate towards targetPostargetPos - the position of the target (for example the camera) towards which to rotate the objectup - the up axis used to orient the objectbillboardSpherical(Vector3fc, Vector3fc)public Matrix4f billboardSpherical(Vector3fc objPos, Vector3fc targetPos)
objPos towards
a target position at targetPos using a shortest arc rotation by not preserving any up vector of the object.
This method can be used to create the complete model transformation for a given object, including the translation of the object to
its position objPos.
In order to specify an up vector which needs to be maintained when rotating the +Z axis of the object,
use billboardSpherical(Vector3fc, Vector3fc, Vector3fc).
objPos - the position of the object to rotate towards targetPostargetPos - the position of the target (for example the camera) towards which to rotate the objectbillboardSpherical(Vector3fc, Vector3fc, Vector3fc)public boolean equals(Matrix4fc m, float delta)
Matrix4fcthis matrix with the given matrix using the given delta
and return whether all of them are equal within a maximum difference of delta.
Please note that this method is not used by any data structure such as ArrayList HashSet or HashMap
and their operations, such as ArrayList.contains(Object) or HashSet.remove(Object), since those
data structures only use the Object.equals(Object) and Object.hashCode() methods.
public Matrix4f pick(float x, float y, float width, float height, int[] viewport, Matrix4f dest)
Matrix4fc(x, y) as the pick center
and the given (width, height) as the size of the picking region in window coordinates, and store the result
in dest.pick in interface Matrix4fcx - the x coordinate of the picking region center in window coordinatesy - the y coordinate of the picking region center in window coordinateswidth - the width of the picking region in window coordinatesheight - the height of the picking region in window coordinatesviewport - the viewport described by [x, y, width, height]dest - the destination matrix, which will hold the resultpublic Matrix4f pick(float x, float y, float width, float height, int[] viewport)
(x, y) as the pick center
and the given (width, height) as the size of the picking region in window coordinates.x - the x coordinate of the picking region center in window coordinatesy - the y coordinate of the picking region center in window coordinateswidth - the width of the picking region in window coordinatesheight - the height of the picking region in window coordinatesviewport - the viewport described by [x, y, width, height]public boolean isAffine()
Matrix4fc(0, 0, 0, 1).public Matrix4f swap(Matrix4f other)
this matrix with the given other matrix.other - the other matrix to exchange the values withpublic Matrix4f arcball(float radius, float centerX, float centerY, float centerZ, float angleX, float angleY, Matrix4f dest)
Matrix4fcradius and center (centerX, centerY, centerZ)
position of the arcball and the specified X and Y rotation angles, and store the result in dest.
This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-centerX, -centerY, -centerZ)
arcball in interface Matrix4fcradius - the arcball radiuscenterX - the x coordinate of the center position of the arcballcenterY - the y coordinate of the center position of the arcballcenterZ - the z coordinate of the center position of the arcballangleX - the rotation angle around the X axis in radiansangleY - the rotation angle around the Y axis in radiansdest - will hold the resultpublic Matrix4f arcball(float radius, Vector3fc center, float angleX, float angleY, Matrix4f dest)
Matrix4fcradius and center
position of the arcball and the specified X and Y rotation angles, and store the result in dest.
This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z)
public Matrix4f arcball(float radius, float centerX, float centerY, float centerZ, float angleX, float angleY)
radius and center (centerX, centerY, centerZ)
position of the arcball and the specified X and Y rotation angles.
This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-centerX, -centerY, -centerZ)
radius - the arcball radiuscenterX - the x coordinate of the center position of the arcballcenterY - the y coordinate of the center position of the arcballcenterZ - the z coordinate of the center position of the arcballangleX - the rotation angle around the X axis in radiansangleY - the rotation angle around the Y axis in radianspublic Matrix4f arcball(float radius, Vector3fc center, float angleX, float angleY)
radius and center
position of the arcball and the specified X and Y rotation angles.
This method is equivalent to calling: translate(0, 0, -radius).rotateX(angleX).rotateY(angleY).translate(-center.x, -center.y, -center.z)
radius - the arcball radiuscenter - the center position of the arcballangleX - the rotation angle around the X axis in radiansangleY - the rotation angle around the Y axis in radianspublic Matrix4f frustumAabb(Vector3f min, Vector3f max)
this matrix and store the minimum corner
coordinates in the given min and the maximum corner coordinates in the given max vector.
The matrix this is assumed to be the inverse of the origial view-projection matrix
for which to compute the axis-aligned bounding box in world-space.
The axis-aligned bounding box of the unit frustum is (-1, -1, -1), (1, 1, 1).
frustumAabb in interface Matrix4fcmin - will hold the minimum corner coordinates of the axis-aligned bounding boxmax - will hold the maximum corner coordinates of the axis-aligned bounding boxpublic Matrix4f projectedGridRange(Matrix4fc projector, float sLower, float sUpper, Matrix4f dest)
Matrix4fcthis, and store that range matrix into dest.
If the projected grid will not be visible then this method returns null.
This method uses the y = 0 plane for the projection.
projectedGridRange in interface Matrix4fcprojector - the projector view-projection transformationsLower - the lower (smallest) Y-coordinate which any transformed vertex might have while still being visible on the projected gridsUpper - the upper (highest) Y-coordinate which any transformed vertex might have while still being visible on the projected griddest - will hold the resulting range matrixnull if the projected grid will not be visiblepublic Matrix4f perspectiveFrustumSlice(float near, float far, Matrix4f dest)
this perspective frustum transformation matrix
and store the result in dest.
This method only works if this is a perspective projection frustum transformation, for example obtained
via perspective() or frustum().
perspectiveFrustumSlice in interface Matrix4fcnear - the new near clip plane distancefar - the new far clip plane distancedest - will hold the resulting matrixperspective(float, float, float, float),
frustum(float, float, float, float, float, float)public Matrix4f orthoCrop(Matrix4fc view, Matrix4f dest)
this
into the given affine view transformation.
The transformation represented by this must be given as the inverse of a typical combined camera view-projection
transformation, whose projection can be either orthographic or perspective.
The view must be an affine transformation which in the application of Cascaded Shadow Maps is usually the light view transformation.
It be obtained via any affine transformation or for example via lookAt().
Reference: OpenGL SDK - Cascaded Shadow Maps
public Matrix4f trapezoidCrop(float p0x, float p0y, float p1x, float p1y, float p2x, float p2y, float p3x, float p3y)
this matrix to a perspective transformation that maps the trapezoid spanned by the four corner coordinates
(p0x, p0y), (p1x, p1y), (p2x, p2y) and (p3x, p3y) to the unit square [(-1, -1)..(+1, +1)].
The corner coordinates are given in counter-clockwise order starting from the left 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.
Reference: Trapezoidal Shadow Maps (TSM) - Recipe
p0x - the x coordinate of the left corner at the shorter edge of the trapezoidp0y - the y coordinate of the left corner at the shorter edge of the trapezoidp1x - the x coordinate of the right corner at the shorter edge of the trapezoidp1y - the y coordinate of the right corner at the shorter edge of the trapezoidp2x - the x coordinate of the right corner at the longer edge of the trapezoidp2y - the y coordinate of the right corner at the longer edge of the trapezoidp3x - the x coordinate of the left corner at the longer edge of the trapezoidp3y - the y coordinate of the left corner at the longer edge of the trapezoidpublic Matrix4f transformAab(float minX, float minY, float minZ, float maxX, float maxY, float maxZ, Vector3f outMin, Vector3f outMax)
Matrix4fc(minX, minY, minZ) and maximum corner (maxX, maxY, maxZ)
by this affine matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin
and maximum corner stored in outMax.
Reference: http://dev.theomader.com
transformAab in interface Matrix4fcminX - the x coordinate of the minimum corner of the axis-aligned boxminY - the y coordinate of the minimum corner of the axis-aligned boxminZ - the z coordinate of the minimum corner of the axis-aligned boxmaxX - the x coordinate of the maximum corner of the axis-aligned boxmaxY - the y coordinate of the maximum corner of the axis-aligned boxmaxZ - the y coordinate of the maximum corner of the axis-aligned boxoutMin - will hold the minimum corner of the resulting axis-aligned boxoutMax - will hold the maximum corner of the resulting axis-aligned boxpublic Matrix4f transformAab(Vector3fc min, Vector3fc max, Vector3f outMin, Vector3f outMax)
Matrix4fcmin and maximum corner max
by this affine matrix and compute the axis-aligned box of the result whose minimum corner is stored in outMin
and maximum corner stored in outMax.transformAab in interface Matrix4fcmin - the minimum corner of the axis-aligned boxmax - the maximum corner of the axis-aligned boxoutMin - will hold the minimum corner of the resulting axis-aligned boxoutMax - will hold the maximum corner of the resulting axis-aligned boxpublic Matrix4f lerp(Matrix4fc other, float t)
this and other using the given interpolation factor t
and store the result in this.
If t is 0.0 then the result is this. If the interpolation factor is 1.0
then the result is other.
other - the other matrixt - the interpolation factor between 0.0 and 1.0public Matrix4f lerp(Matrix4fc other, float t, Matrix4f dest)
Matrix4fcthis and other using the given interpolation factor t
and store the result in dest.
If t is 0.0 then the result is this. If the interpolation factor is 1.0
then the result is other.
public Matrix4f rotateTowards(Vector3fc dir, Vector3fc up, Matrix4f dest)
+Z axis with dir
and store the result in dest.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying it,
use rotationTowards().
This method is equivalent to calling: mulAffine(new Matrix4f().lookAt(new Vector3f(), new Vector3f(dir).negate(), up).invertAffine(), dest)
rotateTowards in interface Matrix4fcdir - the direction to rotate towardsup - the up vectordest - will hold the resultrotateTowards(float, float, float, float, float, float, Matrix4f),
rotationTowards(Vector3fc, Vector3fc)public Matrix4f rotateTowards(Vector3fc dir, Vector3fc up)
+Z axis with dir.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying it,
use rotationTowards().
This method is equivalent to calling: mulAffine(new Matrix4f().lookAt(new Vector3f(), new Vector3f(dir).negate(), up).invertAffine())
dir - the direction to orient towardsup - the up vectorrotateTowards(float, float, float, float, float, float),
rotationTowards(Vector3fc, Vector3fc)public Matrix4f rotateTowards(float dirX, float dirY, float dirZ, float upX, float upY, float upZ)
+Z axis with (dirX, dirY, dirZ).
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying it,
use rotationTowards().
This method is equivalent to calling: mulAffine(new Matrix4f().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine())
dirX - the x-coordinate of the direction to rotate towardsdirY - the y-coordinate of the direction to rotate towardsdirZ - the z-coordinate of the direction to rotate towardsupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorrotateTowards(Vector3fc, Vector3fc),
rotationTowards(float, float, float, float, float, float)public Matrix4f rotateTowards(float dirX, float dirY, float dirZ, float upX, float upY, float upZ, Matrix4f dest)
+Z axis with (dirX, dirY, dirZ)
and store the result in dest.
If M is this matrix and L the lookat matrix,
then the new matrix will be M * L. So when transforming a
vector v with the new matrix by using M * L * v,
the lookat transformation will be applied first!
In order to set the matrix to a rotation transformation without post-multiplying it,
use rotationTowards().
This method is equivalent to calling: mulAffine(new Matrix4f().lookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine(), dest)
rotateTowards in interface Matrix4fcdirX - the x-coordinate of the direction to rotate towardsdirY - the y-coordinate of the direction to rotate towardsdirZ - the z-coordinate of the direction to rotate towardsupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectordest - will hold the resultrotateTowards(Vector3fc, Vector3fc),
rotationTowards(float, float, float, float, float, float)public Matrix4f rotationTowards(Vector3fc dir, Vector3fc up)
-z axis with dir.
In order to apply the rotation transformation to a previous existing transformation,
use rotateTowards.
This method is equivalent to calling: setLookAt(new Vector3f(), new Vector3f(dir).negate(), up).invertAffine()
dir - the direction to orient the local -z axis towardsup - the up vectorrotationTowards(Vector3fc, Vector3fc),
rotateTowards(float, float, float, float, float, float)public Matrix4f rotationTowards(float dirX, float dirY, float dirZ, float upX, float upY, float upZ)
-z axis with (dirX, dirY, dirZ).
In order to apply the rotation transformation to a previous existing transformation,
use rotateTowards.
This method is equivalent to calling: setLookAt(0, 0, 0, -dirX, -dirY, -dirZ, upX, upY, upZ).invertAffine()
dirX - the x-coordinate of the direction to rotate towardsdirY - the y-coordinate of the direction to rotate towardsdirZ - the z-coordinate of the direction to rotate towardsupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectorrotateTowards(Vector3fc, Vector3fc),
rotationTowards(float, float, float, float, float, float)public Matrix4f translationRotateTowards(Vector3fc pos, Vector3fc dir, Vector3fc up)
pos and aligns the local -z
axis with dir.
This method is equivalent to calling: translation(pos).rotateTowards(dir, up)
pos - the position to translate todir - the direction to rotate towardsup - the up vectortranslation(Vector3fc),
rotateTowards(Vector3fc, Vector3fc)public Matrix4f translationRotateTowards(float posX, float posY, float posZ, float dirX, float dirY, float dirZ, float upX, float upY, float upZ)
(posX, posY, posZ) and aligns the local -z
axis with (dirX, dirY, dirZ).
This method is equivalent to calling: translation(posX, posY, posZ).rotateTowards(dirX, dirY, dirZ, upX, upY, upZ)
posX - the x-coordinate of the position to translate toposY - the y-coordinate of the position to translate toposZ - the z-coordinate of the position to translate todirX - the x-coordinate of the direction to rotate towardsdirY - the y-coordinate of the direction to rotate towardsdirZ - the z-coordinate of the direction to rotate towardsupX - the x-coordinate of the up vectorupY - the y-coordinate of the up vectorupZ - the z-coordinate of the up vectortranslation(float, float, float),
rotateTowards(float, float, float, float, float, float)public Vector3f getEulerAnglesZYX(Vector3f dest)
this
and store the extracted Euler angles in dest.
This method assumes that the upper left of this only represents a rotation without scaling.
Note that the returned Euler angles must be applied in the order Z * Y * X to obtain the identical matrix.
This means that calling rotateZYX(float, float, float) using the obtained Euler angles will yield
the same rotation as the original matrix from which the Euler angles were obtained, so in the below code the matrix
m2 should be identical to m (disregarding possible floating-point inaccuracies).
Matrix4f m = ...; // <- matrix only representing rotation Matrix4f n = new Matrix4f(); n.rotateZYX(m.getEulerAnglesZYX(new Vector3f()));
Reference: http://nghiaho.com/
getEulerAnglesZYX in interface Matrix4fcdest - will hold the extracted Euler anglespublic Matrix4f affineSpan(Vector3f corner, Vector3f xDir, Vector3f yDir, Vector3f zDir)
affine transformation was applied
and store the resulting corner coordinates in corner and the span vectors in
xDir, yDir and zDir.
That means, given the maximum extents of the coordinate system between [-1..+1] 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 [-1, +1].
This method is equivalent to computing at least three adjacent corners using frustumCorner(int, Vector3f)
and subtracting them to obtain the length and direction of the span vectors.
corner - will hold one corner of the span (usually the corner Matrix4fc.CORNER_NXNYNZ)xDir - will hold the direction and length of the span along the positive X axisyDir - will hold the direction and length of the span along the positive Y axiszDir - will hold the direction and length of the span along the positive z axispublic boolean testPoint(float x,
float y,
float z)
Matrix4fc(x, y, z) is within the frustum defined by this matrix.
This method assumes this matrix to be a transformation from any arbitrary coordinate system/space M
into standard OpenGL clip space and tests whether the given point with the coordinates (x, y, z) given
in space M is within the clip space.
When testing multiple points using the same transformation matrix, FrustumIntersection should be used instead.
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
public boolean testSphere(float x,
float y,
float z,
float r)
Matrix4fcthis matrix.
This method assumes this matrix to be a transformation from any arbitrary coordinate system/space M
into standard OpenGL clip space and tests whether the given sphere with the coordinates (x, y, z) given
in space M is within the clip space.
When testing multiple spheres using the same transformation matrix, or more sophisticated/optimized intersection algorithms are required,
FrustumIntersection should be used instead.
The algorithm implemented by this method is conservative. This means that in certain circumstances a false positive
can occur, when the method returns true for spheres that are actually not visible.
See iquilezles.org for an examination of this problem.
Reference: Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
testSphere in interface Matrix4fcx - the x-coordinate of the sphere's centery - the y-coordinate of the sphere's centerz - the z-coordinate of the sphere's centerr - the sphere's radiustrue if the given sphere is partly or completely inside the frustum; false otherwisepublic boolean testAab(float minX,
float minY,
float minZ,
float maxX,
float maxY,
float maxZ)
Matrix4fcthis matrix.
The box is specified via its min and max corner coordinates.
This method assumes this matrix to be a transformation from any arbitrary coordinate system/space M
into standard OpenGL clip space and tests whether the given axis-aligned box with its minimum corner coordinates (minX, minY, minZ)
and maximum corner coordinates (maxX, maxY, maxZ) given in space M is within the clip space.
When testing multiple axis-aligned boxes using the same transformation matrix, or more sophisticated/optimized intersection algorithms are required,
FrustumIntersection should be used instead.
The algorithm implemented by this method is conservative. This means that in certain circumstances a false positive
can occur, when the method returns -1 for boxes that are actually not visible/do not intersect the frustum.
See iquilezles.org for an examination of this problem.
Reference: Efficient View Frustum Culling
Reference:
Fast Extraction of Viewing Frustum Planes from the World-View-Projection Matrix
testAab in interface Matrix4fcminX - the x-coordinate of the minimum cornerminY - the y-coordinate of the minimum cornerminZ - the z-coordinate of the minimum cornermaxX - the x-coordinate of the maximum cornermaxY - the y-coordinate of the maximum cornermaxZ - the z-coordinate of the maximum cornertrue if the axis-aligned box is completely or partly inside of the frustum; false otherwisepublic Matrix4f obliqueZ(float a, float b)
a and
b.
If M is this matrix and O the oblique transformation matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
oblique transformation will be applied first!
The oblique transformation is defined as:
x' = x + a*z y' = y + a*z z' = zor in matrix form:
1 0 a 0 0 1 b 0 0 0 1 0 0 0 0 1
a - the value for the z factor that applies to xb - the value for the z factor that applies to ypublic Matrix4f obliqueZ(float a, float b, Matrix4f dest)
a and
b and store the result in dest.
If M is this matrix and O the oblique transformation matrix,
then the new matrix will be M * O. So when transforming a
vector v with the new matrix by using M * O * v, the
oblique transformation will be applied first!
The oblique transformation is defined as:
x' = x + a*z y' = y + a*z z' = zor in matrix form:
1 0 a 0 0 1 b 0 0 0 1 0 0 0 0 1
public static void projViewFromRectangle(Vector3f eye, Vector3f p, Vector3f x, Vector3f y, float nearFarDist, boolean zeroToOne, Matrix4f projDest, Matrix4f viewDest)
eye position, a given bottom left corner position p of the near plane rectangle
and the extents of the near plane rectangle along its local x and y axes, and store the resulting matrices
in projDest and viewDest.
This method creates a view and perspective projection matrix assuming that there is a pinhole camera at position eye
projecting the scene onto the near plane defined by the rectangle.
All positions and lengths are in the same (world) unit.
eye - the position of the camerap - the bottom left corner of the near plane rectangle (will map to the bottom left corner in window coordinates)x - the direction and length of the local "bottom/top" X axis/side of the near plane rectangley - the direction and length of the local "left/right" Y axis/side of the near plane rectanglenearFarDist - the distance between the far and near plane (the near plane will be calculated by this method).
If the special value Float.POSITIVE_INFINITY is used, the far clipping plane will be at positive infinity.
If the special value Float.NEGATIVE_INFINITY is used, the near and far planes will be swapped and
the near clipping plane will be at positive infinity.
If a negative value is used (except for Float.NEGATIVE_INFINITY) the near and far planes will be swappedzeroToOne - whether to use Vulkan's and Direct3D's NDC z range of [0..+1] when true
or whether to use OpenGL's NDC z range of [-1..+1] when falseprojDest - will hold the resulting projection matrixviewDest - will hold the resulting view matrixpublic Matrix4f withLookAtUp(Vector3fc up)
positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by positiveZ(Vector3f)) and the
given vector up.
This effectively ensure that the resulting matrix will be equal to the one obtained from
setLookAt(Vector3fc, Vector3fc, Vector3fc) called with the current
local origin of this matrix (as obtained by originAffine(Vector3f)), the sum of this position and the
negated local Z axis as well as the given vector up.
This method must only be called on isAffine() matrices.up - the up vectorpublic Matrix4f withLookAtUp(Vector3fc up, Matrix4f dest)
Matrix4fcMatrix4fc.positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4fc.positiveZ(Vector3f)) and the
given vector up, and store the result in dest.
This effectively ensure that the resulting matrix will be equal to the one obtained from calling
setLookAt(Vector3fc, Vector3fc, Vector3fc) with the current
local origin of this matrix (as obtained by Matrix4fc.originAffine(Vector3f)), the sum of this position and the
negated local Z axis as well as the given vector up.
This method must only be called on Matrix4fc.isAffine() matrices.withLookAtUp in interface Matrix4fcup - the up vectordest - will hold the resultpublic Matrix4f withLookAtUp(float upX, float upY, float upZ)
positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by positiveZ(Vector3f)) and the
given vector (upX, upY, upZ).
This effectively ensure that the resulting matrix will be equal to the one obtained from
setLookAt(float, float, float, float, float, float, float, float, float) called with the current
local origin of this matrix (as obtained by originAffine(Vector3f)), the sum of this position and the
negated local Z axis as well as the given vector (upX, upY, upZ).
This method must only be called on isAffine() matrices.upX - the x coordinate of the up vectorupY - the y coordinate of the up vectorupZ - the z coordinate of the up vectorpublic Matrix4f withLookAtUp(float upX, float upY, float upZ, Matrix4f dest)
Matrix4fcMatrix4fc.positiveY(Vector3f))
will be coplanar to the plane spanned by the local Z axis (as obtained by Matrix4fc.positiveZ(Vector3f)) and the
given vector (upX, upY, upZ), and store the result in dest.
This effectively ensure that the resulting matrix will be equal to the one obtained from calling
setLookAt(float, float, float, float, float, float, float, float, float) called with the current
local origin of this matrix (as obtained by Matrix4fc.originAffine(Vector3f)), the sum of this position and the
negated local Z axis as well as the given vector (upX, upY, upZ).
This method must only be called on Matrix4fc.isAffine() matrices.withLookAtUp in interface Matrix4fcupX - the x coordinate of the up vectorupY - the y coordinate of the up vectorupZ - the z coordinate of the up vectordest - will hold the resultCopyright © 2015–2019 JOML. All rights reserved.