Class Matrix3f
- All Implemented Interfaces:
Externalizable
,Serializable
,Cloneable
,Matrix3fc
- Direct Known Subclasses:
Matrix3fStack
m00 m10 m20
m01 m11 m21
m02 m12 m22
- Author:
- Richard Greenlees, Kai Burjack
- See Also:
-
Field Summary
-
Constructor Summary
ConstructorDescriptionMatrix3f()
Matrix3f
(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) Create a new 3x3 matrix using the supplied float values.Matrix3f
(FloatBuffer buffer) Create a newMatrix3f
by reading its 9 float components from the givenFloatBuffer
at the buffer's current position.Create a newMatrix3f
and make it a copy of the given matrix.Create a newMatrix3f
and initialize its three columns using the supplied vectors. -
Method Summary
Modifier and TypeMethodDescriptionComponent-wise addthis
andother
.Component-wise addthis
andother
and store the result indest
.clone()
cofactor()
Compute the cofactor matrix ofthis
.Compute the cofactor matrix ofthis
and store it intodest
.float
Return the determinant of this matrix.boolean
boolean
Compare the matrix elements ofthis
matrix with the given matrix using the givendelta
and return whether all of them are equal within a maximum difference ofdelta
.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.float
get
(int column, int row) Get the matrix element value at the given column and row.com.google.gwt.typedarrays.shared.Float32Array
get
(int index, com.google.gwt.typedarrays.shared.Float32Array buffer) Store this matrix in column-major order into the suppliedFloat32Array
at the given index.get
(int index, ByteBuffer buffer) Store this matrix in column-major order into the suppliedByteBuffer
starting at the specified absolute buffer position/index.get
(int index, FloatBuffer buffer) Store this matrix in column-major order into the suppliedFloatBuffer
starting at the specified absolute buffer position/index.com.google.gwt.typedarrays.shared.Float32Array
get
(com.google.gwt.typedarrays.shared.Float32Array buffer) Store this matrix in column-major order into the suppliedFloat32Array
.get
(ByteBuffer buffer) Store this matrix in column-major order into the suppliedByteBuffer
at the current bufferposition
.get
(FloatBuffer buffer) Store this matrix in column-major order into the suppliedFloatBuffer
at the current bufferposition
.Get the current values ofthis
matrix and store them intodest
.Get the current values ofthis
matrix and store them as the rotational component ofdest
.get3x4
(int index, ByteBuffer buffer) Store this matrix as 3x4 matrix in column-major order into the suppliedByteBuffer
starting at the specified absolute buffer position/index, with the m03, m13 and m23 components being zero.get3x4
(int index, FloatBuffer buffer) Store this matrix as 3x4 matrix in column-major order into the suppliedFloatBuffer
starting at the specified absolute buffer position/index, with the m03, m13 and m23 components being zero.get3x4
(ByteBuffer buffer) Store this matrix as 3x4 matrix in column-major order into the suppliedByteBuffer
at the current bufferposition
, with the m03, m13 and m23 components being zero.get3x4
(FloatBuffer buffer) Store this matrix as 3x4 matrix in column-major order into the suppliedFloatBuffer
at the current bufferposition
, with the m03, m13 and m23 components being zero.Get the column at the givencolumn
index, starting with0
.getEulerAnglesXYZ
(Vector3f dest) Extract the Euler angles from the rotation represented bythis
matrix and store the extracted Euler angles indest
.getEulerAnglesZYX
(Vector3f dest) Extract the Euler angles from the rotation represented bythis
matrix and store the extracted Euler angles indest
.Get the current values ofthis
matrix and store the represented rotation into the givenQuaterniond
.Get the current values ofthis
matrix and store the represented rotation into the givenQuaternionf
.getRotation
(AxisAngle4f dest) Get the current values ofthis
matrix and store the represented rotation into the givenAxisAngle4f
.Get the row at the givenrow
index, starting with0
.float
getRowColumn
(int row, int column) Get the matrix element value at the given row and column.Get the scaling factors ofthis
matrix for the three base axes.getToAddress
(long address) Store this matrix in column-major order at the given off-heap address.getTransposed
(int index, ByteBuffer buffer) Store the transpose of this matrix in column-major order into the suppliedByteBuffer
starting at the specified absolute buffer position/index.getTransposed
(int index, FloatBuffer buffer) Store the transpose of this matrix in column-major order into the suppliedFloatBuffer
starting at the specified absolute buffer position/index.getTransposed
(ByteBuffer buffer) Store the transpose of this matrix in column-major order into the suppliedByteBuffer
at the current bufferposition
.getTransposed
(FloatBuffer buffer) Store the transpose of this matrix in column-major order into the suppliedFloatBuffer
at the current bufferposition
.Get the current values ofthis
matrix and store the represented rotation into the givenQuaterniond
.Get the current values ofthis
matrix and store the represented rotation into the givenQuaternionf
.int
hashCode()
identity()
Set this matrix to the identity.invert()
Invert this matrix.Invert thethis
matrix and store the result indest
.boolean
isFinite()
Linearly interpolatethis
andother
using the given interpolation factort
and store the result inthis
.Linearly interpolatethis
andother
using the given interpolation factort
and store the result indest
.lookAlong
(float dirX, float dirY, float dirZ, float upX, float upY, float upZ) Apply a rotation transformation to this matrix to make-z
point alongdir
.Apply a rotation transformation to this matrix to make-z
point alongdir
and store the result indest
.Apply a rotation transformation to this matrix to make-z
point alongdir
.Apply a rotation transformation to this matrix to make-z
point alongdir
and store the result indest
.float
m00()
Return the value of the matrix element at column 0 and row 0.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.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.m02
(float m02) Set the value of the matrix element at column 0 and row 2.float
m10()
Return the value of the matrix element at column 1 and row 0.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.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.m12
(float m12) Set the value of the matrix element at column 1 and row 2.float
m20()
Return the value of the matrix element at column 2 and row 0.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.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.m22
(float m22) Set the value of the matrix element at column 2 and row 2.Multiplythis
by the matrixMultiplythis
by the matrixmapnXnYZ()
Multiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixmapnXnZY()
Multiplythis
by the matrixMultiplythis
by the matrixmapnXYnZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapnXZnY()
Multiplythis
by the matrixMultiplythis
by the matrixmapnXZY()
Multiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixmapnYnXZ()
Multiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixmapnYnZX()
Multiplythis
by the matrixMultiplythis
by the matrixmapnYXnZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapnYXZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapnYZnX()
Multiplythis
by the matrixMultiplythis
by the matrixmapnYZX()
Multiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixmapnZnXY()
Multiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixMultiplythis
by the matrixmapnZnYX()
Multiplythis
by the matrixMultiplythis
by the matrixmapnZXnY()
Multiplythis
by the matrixMultiplythis
by the matrixmapnZXY()
Multiplythis
by the matrixMultiplythis
by the matrixmapnZYnX()
Multiplythis
by the matrixMultiplythis
by the matrixmapnZYX()
Multiplythis
by the matrixMultiplythis
by the matrixmapXnYnZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapXnZnY()
Multiplythis
by the matrixMultiplythis
by the matrixmapXnZY()
Multiplythis
by the matrixMultiplythis
by the matrixmapXZnY()
Multiplythis
by the matrixMultiplythis
by the matrixmapXZY()
Multiplythis
by the matrixMultiplythis
by the matrixmapYnXnZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapYnXZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapYnZnX()
Multiplythis
by the matrixMultiplythis
by the matrixmapYnZX()
Multiplythis
by the matrixMultiplythis
by the matrixmapYXnZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapYXZ()
Multiplythis
by the matrixMultiplythis
by the matrixmapYZnX()
Multiplythis
by the matrixMultiplythis
by the matrixmapYZX()
Multiplythis
by the matrixMultiplythis
by the matrixmapZnXnY()
Multiplythis
by the matrixMultiplythis
by the matrixmapZnXY()
Multiplythis
by the matrixMultiplythis
by the matrixmapZnYnX()
Multiplythis
by the matrixMultiplythis
by the matrixmapZnYX()
Multiplythis
by the matrixMultiplythis
by the matrixmapZXnY()
Multiplythis
by the matrixMultiplythis
by the matrixmapZXY()
Multiplythis
by the matrixMultiplythis
by the matrixmapZYnX()
Multiplythis
by the matrixMultiplythis
by the matrixmapZYX()
Multiplythis
by the matrixMultiplythis
by the matrixMultiply this matrix by the suppliedright
matrix.Multiply this matrix by the suppliedright
matrix and store the result indest
.mulComponentWise
(Matrix3fc other) Component-wise multiplythis
byother
.mulComponentWise
(Matrix3fc other, Matrix3f dest) Component-wise multiplythis
byother
and store the result indest
.Pre-multiply this matrix by the suppliedleft
matrix and store the result inthis
.Pre-multiply this matrix by the suppliedleft
matrix and store the result indest
.negateX()
Multiplythis
by the matrixMultiplythis
by the matrixnegateY()
Multiplythis
by the matrixMultiplythis
by the matrixnegateZ()
Multiplythis
by the matrixMultiplythis
by the matrixnormal()
Setthis
matrix to its own normal matrix.Compute a normal matrix fromthis
matrix and store it intodest
.Obtain the direction of+X
before the transformation represented bythis
orthogonal matrix is applied.Obtain the direction of+Y
before the transformation represented bythis
orthogonal matrix is applied.Obtain the direction of+Z
before the transformation represented bythis
orthogonal matrix is applied.obliqueZ
(float a, float b) Apply an oblique projection transformation to this matrix with the given values fora
andb
.Apply an oblique projection transformation to this matrix with the given values fora
andb
and store the result indest
.Obtain the direction of+X
before the transformation represented bythis
matrix is applied.Obtain the direction of+Y
before the transformation represented bythis
matrix is applied.Obtain the direction of+Z
before the transformation represented bythis
matrix is applied.float
quadraticFormProduct
(float x, float y, float z) Compute(x, y, z)^T * this * (x, y, z)
.float
Computev^T * this * v
.void
reflect
(float nx, float ny, float nz) Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal.Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal(nx, ny, nz)
, and store the result indest
.reflect
(Quaternionfc orientation) Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation.reflect
(Quaternionfc orientation, Matrix3f dest) Apply a mirror/reflection transformation to this matrix that reflects through a plane specified via the plane orientation, and store the result indest
.Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal.Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal, and store the result indest
.reflection
(float nx, float ny, float nz) Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.reflection
(Quaternionfc orientation) Set this matrix to a mirror/reflection transformation that reflects through a plane specified via the plane orientation.reflection
(Vector3fc normal) Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.rotate
(float ang, float x, float y, float z) Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components.Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components, and store the result indest
.Apply a rotation transformation, rotating the given radians about the specified axis, to this matrix.Apply a rotation transformation, rotating the given radians about the specified axis and store the result indest
.rotate
(AxisAngle4f axisAngle) Apply a rotation transformation, rotating about the givenAxisAngle4f
, to this matrix.rotate
(AxisAngle4f axisAngle, Matrix3f dest) Apply a rotation transformation, rotating about the givenAxisAngle4f
and store the result indest
.rotate
(Quaternionfc quat) Apply the rotation - and possibly scaling - transformation of the givenQuaternionfc
to this matrix.rotate
(Quaternionfc quat, Matrix3f dest) Apply the rotation - and possibly scaling - transformation of the givenQuaternionfc
to this matrix and store the result indest
.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.rotateLocal
(float ang, float x, float y, float z, Matrix3f 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 indest
.rotateLocal
(Quaternionfc quat) Pre-multiply the rotation - and possibly scaling - transformation of the givenQuaternionfc
to this matrix.rotateLocal
(Quaternionfc quat, Matrix3f dest) Pre-multiply the rotation - and possibly scaling - transformation of the givenQuaternionfc
to this matrix and store the result indest
.rotateLocalX
(float ang) Pre-multiply a rotation to this matrix by rotating the given amount of radians about the X axis.rotateLocalX
(float ang, Matrix3f 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 indest
.rotateLocalY
(float ang) Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y axis.rotateLocalY
(float ang, Matrix3f 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 indest
.rotateLocalZ
(float ang) Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Z axis.rotateLocalZ
(float ang, Matrix3f 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 indest
.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 withdirection
.rotateTowards
(float dirX, float dirY, float dirZ, float upX, float upY, float upZ, Matrix3f dest) Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdir
and store the result indest
.rotateTowards
(Vector3fc direction, Vector3fc up) Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdirection
.rotateTowards
(Vector3fc direction, Vector3fc up, Matrix3f dest) Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdirection
and store the result indest
.rotateX
(float ang) Apply rotation about the X axis to this matrix by rotating the given amount of radians.Apply rotation about the X axis to this matrix by rotating the given amount of radians and store the result indest
.rotateXYZ
(float angleX, float angleY, float angleZ) Apply rotation ofangleX
radians about the X axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleZ
radians about the Z axis.Apply rotation ofangleX
radians about the X axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleZ
radians about the Z axis and store the result indest
.Apply rotation ofangles.x
radians about the X axis, followed by a rotation ofangles.y
radians about the Y axis and followed by a rotation ofangles.z
radians about the Z axis.rotateY
(float ang) Apply rotation about the Y axis to this matrix by rotating the given amount of radians.Apply rotation about the Y axis to this matrix by rotating the given amount of radians and store the result indest
.rotateYXZ
(float angleY, float angleX, float angleZ) Apply rotation ofangleY
radians about the Y axis, followed by a rotation ofangleX
radians about the X axis and followed by a rotation ofangleZ
radians about the Z axis.Apply rotation ofangleY
radians about the Y axis, followed by a rotation ofangleX
radians about the X axis and followed by a rotation ofangleZ
radians about the Z axis and store the result indest
.Apply rotation ofangles.y
radians about the Y axis, followed by a rotation ofangles.x
radians about the X axis and followed by a rotation ofangles.z
radians about the Z axis.rotateZ
(float ang) Apply rotation about the Z axis to this matrix by rotating the given amount of radians.Apply rotation about the Z axis to this matrix by rotating the given amount of radians and store the result indest
.rotateZYX
(float angleZ, float angleY, float angleX) Apply rotation ofangleZ
radians about the Z axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleX
radians about the X axis.Apply rotation ofangleZ
radians about the Z axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleX
radians about the X axis and store the result indest
.Apply rotation ofangles.z
radians about the Z axis, followed by a rotation ofangles.y
radians about the Y axis and followed by a rotation ofangles.x
radians about the X axis.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.Set this matrix to a rotation matrix which rotates the given radians about a given axis.rotation
(AxisAngle4f axisAngle) Set this matrix to a rotation transformation using the givenAxisAngle4f
.rotation
(Quaternionfc quat) Set this matrix to the rotation - and possibly scaling - transformation of the givenQuaternionfc
.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 withcenter - eye
.rotationTowards
(Vector3fc dir, Vector3fc up) Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local-z
axis withcenter - eye
.rotationX
(float ang) Set this matrix to a rotation transformation about the X axis.rotationXYZ
(float angleX, float angleY, float angleZ) Set this matrix to a rotation ofangleX
radians about the X axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleZ
radians about the Z axis.rotationY
(float ang) Set this matrix to a rotation transformation about the Y axis.rotationYXZ
(float angleY, float angleX, float angleZ) Set this matrix to a rotation ofangleY
radians about the Y axis, followed by a rotation ofangleX
radians about the X axis and followed by a rotation ofangleZ
radians about the Z axis.rotationZ
(float ang) Set this matrix to a rotation transformation about the Z axis.rotationZYX
(float angleZ, float angleY, float angleX) Set this matrix to a rotation ofangleZ
radians about the Z axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleX
radians about the X axis.scale
(float xyz) Apply scaling to this matrix by uniformly scaling all base axes by the givenxyz
factor.scale
(float x, float y, float z) Apply scaling to this matrix by scaling the base axes by the given x, y and z factors.Apply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result indest
.Apply scaling to this matrix by uniformly scaling all base axes by the givenxyz
factor and store the result indest
.Apply scaling to this matrix by scaling the base axes by the givenxyz.x
,xyz.y
andxyz.z
factors, respectively.Apply scaling tothis
matrix by scaling the base axes by the givenxyz.x
,xyz.y
andxyz.z
factors, respectively and store the result indest
.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.scaleLocal
(float x, float y, float z, Matrix3f dest) Pre-multiply scaling tothis
matrix by scaling the base axes by the given x, y and z factors and store the result indest
.scaling
(float factor) Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given factor.scaling
(float x, float y, float z) Set this matrix to be a simple scale matrix.Set this matrix to be a simple scale matrix which scales the base axes byxyz.x
,xyz.y
andxyz.z
respectively.set
(float[] m) Set the values in this matrix based on the supplied float array.set
(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) Set the values within this matrix to the supplied float values.set
(int column, int row, float value) Set the matrix element at the given column and row to the specified value.set
(int index, ByteBuffer buffer) Set the values of this matrix by reading 9 float values from the givenByteBuffer
in column-major order, starting at the specified absolute buffer position/index.set
(int index, FloatBuffer buffer) Set the values of this matrix by reading 9 float values from the givenFloatBuffer
in column-major order, starting at the specified absolute buffer position/index.set
(ByteBuffer buffer) Set the values of this matrix by reading 9 float values from the givenByteBuffer
in column-major order, starting at its current position.set
(FloatBuffer buffer) Set the values of this matrix by reading 9 float values from the givenFloatBuffer
in column-major order, starting at its current position.set
(AxisAngle4d axisAngle) Set this matrix to be equivalent to the rotation specified by the givenAxisAngle4d
.set
(AxisAngle4f axisAngle) Set this matrix to be equivalent to the rotation specified by the givenAxisAngle4f
.Set the elements of this matrix to the ones inm
.Set the elements of this matrix to the upper left 3x3 of the givenMatrix4fc
.set
(Matrix4x3fc m) Set the elements of this matrix to the left 3x3 submatrix ofm
.set
(Quaterniondc q) Set this matrix to a rotation - and possibly scaling - equivalent to the given quaternion.set
(Quaternionfc q) Set this matrix to be equivalent to the rotation - and possibly scaling - specified by the givenQuaternionfc
.Set the three columns of this matrix to the supplied vectors, respectively.setColumn
(int column, float x, float y, float z) Set the column at the givencolumn
index, starting with0
.Set the column at the givencolumn
index, starting with0
.setFromAddress
(long address) Set the values of this matrix by reading 9 float values from off-heap memory in column-major order, starting at the given address.setLookAlong
(float dirX, float dirY, float dirZ, float upX, float upY, float upZ) Set this matrix to a rotation transformation to make-z
point alongdir
.setLookAlong
(Vector3fc dir, Vector3fc up) Set this matrix to a rotation transformation to make-z
point alongdir
.setRow
(int row, float x, float y, float z) Set the row at the givenrow
index, starting with0
.Set the row at the givenrow
index, starting with0
.setRowColumn
(int row, int column, float value) Set the matrix element at the given row and column to the specified value.setSkewSymmetric
(float a, float b, float c) Set this matrix to a skew-symmetric matrix using the following layout:Store the values of the transpose of the given matrixm
intothis
matrix.Component-wise subtractsubtrahend
fromthis
.Component-wise subtractsubtrahend
fromthis
and store the result indest
.Exchange the values ofthis
matrix with the givenother
matrix.toString()
Return a string representation of this matrix.toString
(NumberFormat formatter) Return a string representation of this matrix by formatting the matrix elements with the givenNumberFormat
.Transform the vector(x, y, z)
by this matrix and store the result indest
.Transform the given vector by this matrix.Transform the given vector by this matrix and store the result indest
.transformTranspose
(float x, float y, float z, Vector3f dest) Transform the vector(x, y, z)
by the transpose of this matrix and store the result indest
.Transform the given vector by the transpose of this matrix.transformTranspose
(Vector3fc v, Vector3f dest) Transform the given vector by the transpose of this matrix and store the result indest
.Transpose this matrix.Transposethis
matrix and store the result indest
.void
zero()
Set all values within this matrix to zero.
-
Field Details
-
m00
public float m00 -
m01
public float m01 -
m02
public float m02 -
m10
public float m10 -
m11
public float m11 -
m12
public float m12 -
m20
public float m20 -
m21
public float m21 -
m22
public float m22
-
-
Constructor Details
-
Matrix3f
public Matrix3f() -
Matrix3f
Create a newMatrix3f
by setting its uppper left 2x2 submatrix to the values of the givenMatrix2fc
and the rest to identity.- Parameters:
mat
- theMatrix2fc
-
Matrix3f
Create a newMatrix3f
and make it a copy of the given matrix.- Parameters:
mat
- theMatrix3fc
to copy the values from
-
Matrix3f
- Parameters:
mat
- theMatrix4fc
to copy the values from
-
Matrix3f
public Matrix3f(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) Create a new 3x3 matrix using the supplied float values. The order of the parameter is column-major, so the first three parameters specify the three elements of the first column.- Parameters:
m00
- the value of m00m01
- the value of m01m02
- the value of m02m10
- the value of m10m11
- the value of m11m12
- the value of m12m20
- the value of m20m21
- the value of m21m22
- the value of m22
-
Matrix3f
Create a newMatrix3f
by reading its 9 float components from the givenFloatBuffer
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.
- Parameters:
buffer
- theFloatBuffer
to read the matrix values from
-
Matrix3f
Create a newMatrix3f
and initialize its three columns using the supplied vectors.- Parameters:
col0
- the first columncol1
- the second columncol2
- the third column
-
-
Method Details
-
m00
public float m00()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 0 and row 0. -
m01
public float m01()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 0 and row 1. -
m02
public float m02()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 0 and row 2. -
m10
public float m10()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 1 and row 0. -
m11
public float m11()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 1 and row 1. -
m12
public float m12()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 1 and row 2. -
m20
public float m20()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 2 and row 0. -
m21
public float m21()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 2 and row 1. -
m22
public float m22()Description copied from interface:Matrix3fc
Return the value of the matrix element at column 2 and row 2. -
m00
Set the value of the matrix element at column 0 and row 0.- Parameters:
m00
- the new value- Returns:
- this
-
m01
Set the value of the matrix element at column 0 and row 1.- Parameters:
m01
- the new value- Returns:
- this
-
m02
Set the value of the matrix element at column 0 and row 2.- Parameters:
m02
- the new value- Returns:
- this
-
m10
Set the value of the matrix element at column 1 and row 0.- Parameters:
m10
- the new value- Returns:
- this
-
m11
Set the value of the matrix element at column 1 and row 1.- Parameters:
m11
- the new value- Returns:
- this
-
m12
Set the value of the matrix element at column 1 and row 2.- Parameters:
m12
- the new value- Returns:
- this
-
m20
Set the value of the matrix element at column 2 and row 0.- Parameters:
m20
- the new value- Returns:
- this
-
m21
Set the value of the matrix element at column 2 and row 1.- Parameters:
m21
- the new value- Returns:
- this
-
m22
Set the value of the matrix element at column 2 and row 2.- Parameters:
m22
- the new value- Returns:
- this
-
set
Set the elements of this matrix to the ones inm
.- Parameters:
m
- the matrix to copy the elements from- Returns:
- this
-
setTransposed
Store the values of the transpose of the given matrixm
intothis
matrix.- Parameters:
m
- the matrix to copy the transposed values from- Returns:
- this
-
set
Set the elements of this matrix to the left 3x3 submatrix ofm
.- Parameters:
m
- the matrix to copy the elements from- Returns:
- this
-
set
Set the elements of this matrix to the upper left 3x3 of the givenMatrix4fc
.- Parameters:
mat
- theMatrix4fc
to copy the values from- Returns:
- this
-
set
- Parameters:
mat
- theMatrix2fc
- Returns:
- this
- See Also:
-
set
Set this matrix to be equivalent to the rotation specified by the givenAxisAngle4f
.- Parameters:
axisAngle
- theAxisAngle4f
- Returns:
- this
-
set
Set this matrix to be equivalent to the rotation specified by the givenAxisAngle4d
.- Parameters:
axisAngle
- theAxisAngle4d
- Returns:
- this
-
set
Set this matrix to be equivalent to the rotation - and possibly scaling - specified by the givenQuaternionfc
.This method is equivalent to calling:
rotation(q)
Reference: http://www.euclideanspace.com/
- Parameters:
q
- theQuaternionfc
- Returns:
- this
- See Also:
-
set
Set this matrix to a rotation - and possibly scaling - equivalent to the given quaternion.Reference: http://www.euclideanspace.com/
- Parameters:
q
- the quaternion- Returns:
- this
-
mul
Multiply this matrix by the suppliedright
matrix.If
M
isthis
matrix andR
theright
matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the transformation of the right matrix will be applied first!- Parameters:
right
- the right operand of the matrix multiplication- Returns:
- this
-
mul
Description copied from interface:Matrix3fc
Multiply this matrix by the suppliedright
matrix and store the result indest
.If
M
isthis
matrix andR
theright
matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the transformation of the right matrix will be applied first! -
mulLocal
Pre-multiply this matrix by the suppliedleft
matrix and store the result inthis
.If
M
isthis
matrix andL
theleft
matrix, then the new matrix will beL * M
. So when transforming a vectorv
with the new matrix by usingL * M * v
, the transformation ofthis
matrix will be applied first!- Parameters:
left
- the left operand of the matrix multiplication- Returns:
- this
-
mulLocal
Description copied from interface:Matrix3fc
Pre-multiply this matrix by the suppliedleft
matrix and store the result indest
.If
M
isthis
matrix andL
theleft
matrix, then the new matrix will beL * M
. So when transforming a vectorv
with the new matrix by usingL * M * v
, the transformation ofthis
matrix will be applied first! -
set
public Matrix3f set(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) Set the values within this matrix to the supplied float values. The result looks like this:m00, m10, m20
m01, m11, m21
m02, m12, m22- Parameters:
m00
- the new value of m00m01
- the new value of m01m02
- the new value of m02m10
- the new value of m10m11
- the new value of m11m12
- the new value of m12m20
- the new value of m20m21
- the new value of m21m22
- the new value of m22- Returns:
- this
-
set
Set the values in this matrix based on the supplied float array. The result looks like this:0, 3, 6
1, 4, 7
2, 5, 8
This method only uses the first 9 values, all others are ignored.- Parameters:
m
- the array to read the matrix values from- Returns:
- this
-
set
Set the three columns of this matrix to the supplied vectors, respectively.- Parameters:
col0
- the first columncol1
- the second columncol2
- the third column- Returns:
- this
-
determinant
public float determinant()Description copied from interface:Matrix3fc
Return the determinant of this matrix.- Specified by:
determinant
in interfaceMatrix3fc
- Returns:
- the determinant
-
invert
Invert this matrix.- Returns:
- this
-
invert
Description copied from interface:Matrix3fc
Invert thethis
matrix and store the result indest
. -
transpose
Transpose this matrix.- Returns:
- this
-
transpose
Description copied from interface:Matrix3fc
Transposethis
matrix and store the result indest
. -
toString
Return a string representation of this matrix.This method creates a new
DecimalFormat
on every invocation with the format string "0.000E0;-
". -
toString
Return a string representation of this matrix by formatting the matrix elements with the givenNumberFormat
.- Parameters:
formatter
- theNumberFormat
used to format the matrix values with- Returns:
- the string representation
-
get
Get the current values ofthis
matrix and store them intodest
.This is the reverse method of
set(Matrix3fc)
and allows to obtain intermediate calculation results when chaining multiple transformations. -
get
Description copied from interface:Matrix3fc
Get the current values ofthis
matrix and store them as the rotational component ofdest
. All other values ofdest
will be set to identity. -
getRotation
Description copied from interface:Matrix3fc
Get the current values ofthis
matrix and store the represented rotation into the givenAxisAngle4f
.- Specified by:
getRotation
in interfaceMatrix3fc
- Parameters:
dest
- the destinationAxisAngle4f
- Returns:
- the passed in destination
- See Also:
-
getUnnormalizedRotation
Description copied from interface:Matrix3fc
Get the current values ofthis
matrix and store the represented rotation into the givenQuaternionf
.This method assumes that the three column vectors of this matrix are not normalized and thus allows to ignore any additional scaling factor that is applied to the matrix.
- Specified by:
getUnnormalizedRotation
in interfaceMatrix3fc
- Parameters:
dest
- the destinationQuaternionf
- Returns:
- the passed in destination
- See Also:
-
getNormalizedRotation
Description copied from interface:Matrix3fc
Get the current values ofthis
matrix and store the represented rotation into the givenQuaternionf
.This method assumes that the three column vectors of this matrix are normalized.
- Specified by:
getNormalizedRotation
in interfaceMatrix3fc
- Parameters:
dest
- the destinationQuaternionf
- Returns:
- the passed in destination
- See Also:
-
getUnnormalizedRotation
Description copied from interface:Matrix3fc
Get the current values ofthis
matrix and store the represented rotation into the givenQuaterniond
.This method assumes that the three column vectors of this matrix are not normalized and thus allows to ignore any additional scaling factor that is applied to the matrix.
- Specified by:
getUnnormalizedRotation
in interfaceMatrix3fc
- Parameters:
dest
- the destinationQuaterniond
- Returns:
- the passed in destination
- See Also:
-
getNormalizedRotation
Description copied from interface:Matrix3fc
Get the current values ofthis
matrix and store the represented rotation into the givenQuaterniond
.This method assumes that the three column vectors of this matrix are normalized.
- Specified by:
getNormalizedRotation
in interfaceMatrix3fc
- Parameters:
dest
- the destinationQuaterniond
- Returns:
- the passed in destination
- See Also:
-
get
Description copied from interface:Matrix3fc
Store this matrix in column-major order into the suppliedFloatBuffer
at the current bufferposition
.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
Matrix3fc.get(int, FloatBuffer)
, taking the absolute position as parameter. -
get
Description copied from interface:Matrix3fc
Store this matrix in column-major order into the suppliedFloatBuffer
starting at the specified absolute buffer position/index.This method will not increment the position of the given FloatBuffer.
-
get
Description copied from interface:Matrix3fc
Store this matrix in column-major order into the suppliedByteBuffer
at the current bufferposition
.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
Matrix3fc.get(int, ByteBuffer)
, taking the absolute position as parameter. -
get
Description copied from interface:Matrix3fc
Store this matrix in column-major order into the suppliedByteBuffer
starting at the specified absolute buffer position/index.This method will not increment the position of the given ByteBuffer.
-
get3x4
Description copied from interface:Matrix3fc
Store this matrix as 3x4 matrix in column-major order into the suppliedFloatBuffer
at the current bufferposition
, with the m03, m13 and m23 components being zero.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
Matrix3fc.get3x4(int, FloatBuffer)
, taking the absolute position as parameter. -
get3x4
Description copied from interface:Matrix3fc
Store this matrix as 3x4 matrix in column-major order into the suppliedFloatBuffer
starting at the specified absolute buffer position/index, with the m03, m13 and m23 components being zero.This method will not increment the position of the given FloatBuffer.
-
get3x4
Description copied from interface:Matrix3fc
Store this matrix as 3x4 matrix in column-major order into the suppliedByteBuffer
at the current bufferposition
, with the m03, m13 and m23 components being zero.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
Matrix3fc.get3x4(int, ByteBuffer)
, taking the absolute position as parameter. -
get3x4
Description copied from interface:Matrix3fc
Store this matrix as 3x4 matrix in column-major order into the suppliedByteBuffer
starting at the specified absolute buffer position/index, with the m03, m13 and m23 components being zero.This method will not increment the position of the given ByteBuffer.
-
getTransposed
Description copied from interface:Matrix3fc
Store the transpose of this matrix in column-major order into the suppliedFloatBuffer
at the current bufferposition
.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
Matrix3fc.getTransposed(int, FloatBuffer)
, taking the absolute position as parameter.- Specified by:
getTransposed
in interfaceMatrix3fc
- Parameters:
buffer
- will receive the values of this matrix in column-major order at its current position- Returns:
- the passed in buffer
- See Also:
-
getTransposed
Description copied from interface:Matrix3fc
Store the transpose of this matrix in column-major order into the suppliedFloatBuffer
starting at the specified absolute buffer position/index.This method will not increment the position of the given FloatBuffer.
- Specified by:
getTransposed
in interfaceMatrix3fc
- Parameters:
index
- the absolute position into the FloatBufferbuffer
- will receive the values of this matrix in column-major order- Returns:
- the passed in buffer
-
getTransposed
Description copied from interface:Matrix3fc
Store the transpose of this matrix in column-major order into the suppliedByteBuffer
at the current bufferposition
.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
Matrix3fc.getTransposed(int, ByteBuffer)
, taking the absolute position as parameter.- Specified by:
getTransposed
in interfaceMatrix3fc
- Parameters:
buffer
- will receive the values of this matrix in column-major order at its current position- Returns:
- the passed in buffer
- See Also:
-
getTransposed
Description copied from interface:Matrix3fc
Store the transpose of this matrix in column-major order into the suppliedByteBuffer
starting at the specified absolute buffer position/index.This method will not increment the position of the given ByteBuffer.
- Specified by:
getTransposed
in interfaceMatrix3fc
- Parameters:
index
- the absolute position into the ByteBufferbuffer
- will receive the values of this matrix in column-major order- Returns:
- the passed in buffer
-
getToAddress
Description copied from interface:Matrix3fc
Store this matrix in column-major order at the given off-heap address.This method will throw an
UnsupportedOperationException
when JOML is used with `-Djoml.nounsafe`.This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process.
- Specified by:
getToAddress
in interfaceMatrix3fc
- Parameters:
address
- the off-heap address where to store this matrix- Returns:
- this
-
get
public float[] get(float[] arr, int offset) Description copied from interface:Matrix3fc
Store this matrix into the supplied float array in column-major order at the given offset. -
get
public float[] get(float[] arr) Description copied from interface:Matrix3fc
Store this matrix into the supplied float array in column-major order.In order to specify an explicit offset into the array, use the method
Matrix3fc.get(float[], int)
. -
set
Set the values of this matrix by reading 9 float values from the givenFloatBuffer
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.
- Parameters:
buffer
- the FloatBuffer to read the matrix values from in column-major order- Returns:
- this
-
set
Set the values of this matrix by reading 9 float values from the givenByteBuffer
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.
- Parameters:
buffer
- the ByteBuffer to read the matrix values from in column-major order- Returns:
- this
-
set
Set the values of this matrix by reading 9 float values from the givenFloatBuffer
in column-major order, starting at the specified absolute buffer position/index.The FloatBuffer is expected to contain the values in column-major order.
The position of the FloatBuffer will not be changed by this method.
- Parameters:
index
- the absolute position into the FloatBufferbuffer
- the FloatBuffer to read the matrix values from in column-major order- Returns:
- this
-
set
Set the values of this matrix by reading 9 float values from the givenByteBuffer
in column-major order, starting at the specified absolute buffer position/index.The ByteBuffer is expected to contain the values in column-major order.
The position of the ByteBuffer will not be changed by this method.
- Parameters:
index
- the absolute position into the ByteBufferbuffer
- the ByteBuffer to read the matrix values from in column-major order- Returns:
- this
-
setFromAddress
Set the values of this matrix by reading 9 float values from off-heap memory in column-major order, starting at the given address.This method will throw an
UnsupportedOperationException
when JOML is used with `-Djoml.nounsafe`.This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process.
- Parameters:
address
- the off-heap memory address to read the matrix values from in column-major order- Returns:
- this
-
zero
Set all values within this matrix to zero.- Returns:
- this
-
identity
Set this matrix to the identity.- Returns:
- this
-
scale
Description copied from interface:Matrix3fc
Apply scaling tothis
matrix by scaling the base axes by the givenxyz.x
,xyz.y
andxyz.z
factors, respectively and store the result indest
.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beM * S
. So when transforming a vectorv
with the new matrix by usingM * S * v
, the scaling will be applied first! -
scale
Apply scaling to this matrix by scaling the base axes by the givenxyz.x
,xyz.y
andxyz.z
factors, respectively.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beM * S
. So when transforming a vectorv
with the new matrix by usingM * S * v
, the scaling will be applied first!- Parameters:
xyz
- the factors of the x, y and z component, respectively- Returns:
- this
-
scale
Description copied from interface:Matrix3fc
Apply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result indest
.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beM * S
. So when transforming a vectorv
with the new matrix by usingM * S * v
, the scaling will be applied first! -
scale
Apply scaling to this matrix by scaling the base axes by the given x, y and z factors.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beM * S
. So when transforming a vectorv
with the new matrix by usingM * S * v
, the scaling will be applied first!- Parameters:
x
- the factor of the x componenty
- the factor of the y componentz
- the factor of the z component- Returns:
- this
-
scale
Description copied from interface:Matrix3fc
Apply scaling to this matrix by uniformly scaling all base axes by the givenxyz
factor and store the result indest
.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beM * S
. So when transforming a vectorv
with the new matrix by usingM * S * v
, the scaling will be applied first! -
scale
Apply scaling to this matrix by uniformly scaling all base axes by the givenxyz
factor.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beM * S
. So when transforming a vectorv
with the new matrix by usingM * S * v
, the scaling will be applied first!- Parameters:
xyz
- the factor for all components- Returns:
- this
- See Also:
-
scaleLocal
Description copied from interface:Matrix3fc
Pre-multiply scaling tothis
matrix by scaling the base axes by the given x, y and z factors and store the result indest
.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beS * M
. So when transforming a vectorv
with the new matrix by usingS * M * v
, the scaling will be applied last!- Specified by:
scaleLocal
in interfaceMatrix3fc
- Parameters:
x
- the factor of the x componenty
- the factor of the y componentz
- the factor of the z componentdest
- will hold the result- Returns:
- dest
-
scaleLocal
Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors.If
M
isthis
matrix andS
the scaling matrix, then the new matrix will beS * M
. So when transforming a vectorv
with the new matrix by usingS * M * v
, the scaling will be applied last!- Parameters:
x
- the factor of the x componenty
- the factor of the y componentz
- the factor of the z component- Returns:
- this
-
scaling
Set this matrix to be a simple scale matrix, which scales all axes uniformly by the given 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.- Parameters:
factor
- the scale factor in x, y and z- Returns:
- this
- See Also:
-
scaling
Set this matrix to be a simple scale matrix.- Parameters:
x
- the scale in xy
- the scale in yz
- the scale in z- Returns:
- this
-
scaling
Set this matrix to be a simple scale matrix which scales the base axes byxyz.x
,xyz.y
andxyz.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.- Parameters:
xyz
- the scale in x, y and z respectively- Returns:
- this
- See Also:
-
rotation
Set this matrix to a rotation matrix which rotates the given radians about a given 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.- Parameters:
angle
- the angle in radiansaxis
- the axis to rotate about (needs to benormalized
)- Returns:
- this
- See Also:
-
rotation
Set this matrix to a rotation transformation using the givenAxisAngle4f
.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
- Parameters:
axisAngle
- theAxisAngle4f
(needs to benormalized
)- Returns:
- this
- See Also:
-
rotation
Set this matrix to a rotation matrix which rotates the given radians about a given 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.
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
- Parameters:
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 axis- Returns:
- this
- See Also:
-
rotationX
Set this matrix to a rotation transformation 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.
Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radians- Returns:
- this
-
rotationY
Set this matrix to a rotation transformation about the Y 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.
Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radians- Returns:
- this
-
rotationZ
Set this matrix to a rotation transformation 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.
Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radians- Returns:
- this
-
rotationXYZ
Set this matrix to a rotation ofangleX
radians about the X axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleZ
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)
- Parameters:
angleX
- the angle to rotate about XangleY
- the angle to rotate about YangleZ
- the angle to rotate about Z- Returns:
- this
-
rotationZYX
Set this matrix to a rotation ofangleZ
radians about the Z axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleX
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)
- Parameters:
angleZ
- the angle to rotate about ZangleY
- the angle to rotate about YangleX
- the angle to rotate about X- Returns:
- this
-
rotationYXZ
Set this matrix to a rotation ofangleY
radians about the Y axis, followed by a rotation ofangleX
radians about the X axis and followed by a rotation ofangleZ
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)
- Parameters:
angleY
- the angle to rotate about YangleX
- the angle to rotate about XangleZ
- the angle to rotate about Z- Returns:
- this
-
rotation
Set this matrix to the rotation - and possibly scaling - transformation of the givenQuaternionfc
.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
- Parameters:
quat
- theQuaternionfc
- Returns:
- this
- See Also:
-
transform
Description copied from interface:Matrix3fc
Transform the given vector by this matrix. -
transform
Description copied from interface:Matrix3fc
Transform the given vector by this matrix and store the result indest
. -
transform
Description copied from interface:Matrix3fc
Transform the vector(x, y, z)
by this matrix and store the result indest
. -
transformTranspose
Description copied from interface:Matrix3fc
Transform the given vector by the transpose of this matrix.- Specified by:
transformTranspose
in interfaceMatrix3fc
- Parameters:
v
- the vector to transform- Returns:
- v
-
transformTranspose
Description copied from interface:Matrix3fc
Transform the given vector by the transpose of this matrix and store the result indest
.- Specified by:
transformTranspose
in interfaceMatrix3fc
- Parameters:
v
- the vector to transformdest
- will hold the result- Returns:
- dest
-
transformTranspose
Description copied from interface:Matrix3fc
Transform the vector(x, y, z)
by the transpose of this matrix and store the result indest
.- Specified by:
transformTranspose
in interfaceMatrix3fc
- Parameters:
x
- 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 hold the result- Returns:
- dest
-
writeExternal
- Specified by:
writeExternal
in interfaceExternalizable
- Throws:
IOException
-
readExternal
- Specified by:
readExternal
in interfaceExternalizable
- Throws:
IOException
-
rotateX
Description copied from interface:Matrix3fc
Apply rotation about the X axis to this matrix by rotating the given amount of radians and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
-
rotateX
Apply rotation about the X axis to this matrix by rotating the given amount of radians.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radians- Returns:
- this
-
rotateY
Description copied from interface:Matrix3fc
Apply rotation about the Y axis to this matrix by rotating the given amount of radians and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
-
rotateY
Apply rotation about the Y axis to this matrix by rotating the given amount of radians.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radians- Returns:
- this
-
rotateZ
Description copied from interface:Matrix3fc
Apply rotation about the Z axis to this matrix by rotating the given amount of radians and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
-
rotateZ
Apply rotation about the Z axis to this matrix by rotating the given amount of radians.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radians- Returns:
- this
-
rotateXYZ
Apply rotation ofangles.x
radians about the X axis, followed by a rotation ofangles.y
radians about the Y axis and followed by a rotation ofangles.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateX(angles.x).rotateY(angles.y).rotateZ(angles.z)
- Parameters:
angles
- the Euler angles- Returns:
- this
-
rotateXYZ
Apply rotation ofangleX
radians about the X axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleZ
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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateX(angleX).rotateY(angleY).rotateZ(angleZ)
- Parameters:
angleX
- the angle to rotate about XangleY
- the angle to rotate about YangleZ
- the angle to rotate about Z- Returns:
- this
-
rotateXYZ
Description copied from interface:Matrix3fc
Apply rotation ofangleX
radians about the X axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleZ
radians about the Z axis and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)
-
rotateZYX
Apply rotation ofangles.z
radians about the Z axis, followed by a rotation ofangles.y
radians about the Y axis and followed by a rotation ofangles.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateZ(angles.z).rotateY(angles.y).rotateX(angles.x)
- Parameters:
angles
- the Euler angles- Returns:
- this
-
rotateZYX
Apply rotation ofangleZ
radians about the Z axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleX
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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateZ(angleZ).rotateY(angleY).rotateX(angleX)
- Parameters:
angleZ
- the angle to rotate about ZangleY
- the angle to rotate about YangleX
- the angle to rotate about X- Returns:
- this
-
rotateZYX
Description copied from interface:Matrix3fc
Apply rotation ofangleZ
radians about the Z axis, followed by a rotation ofangleY
radians about the Y axis and followed by a rotation ofangleX
radians about the X axis and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)
-
rotateYXZ
Apply rotation ofangles.y
radians about the Y axis, followed by a rotation ofangles.x
radians about the X axis and followed by a rotation ofangles.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateY(angles.y).rotateX(angles.x).rotateZ(angles.z)
- Parameters:
angles
- the Euler angles- Returns:
- this
-
rotateYXZ
Apply rotation ofangleY
radians about the Y axis, followed by a rotation ofangleX
radians about the X axis and followed by a rotation ofangleZ
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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateY(angleY).rotateX(angleX).rotateZ(angleZ)
- Parameters:
angleY
- the angle to rotate about YangleX
- the angle to rotate about XangleZ
- the angle to rotate about Z- Returns:
- this
-
rotateYXZ
Description copied from interface:Matrix3fc
Apply rotation ofangleY
radians about the Y axis, followed by a rotation ofangleX
radians about the X axis and followed by a rotation ofangleZ
radians about the Z axis and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!This method is equivalent to calling:
rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)
-
rotate
Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
- Parameters:
ang
- the angle in radiansx
- the x component of the axisy
- the y component of the axisz
- the z component of the axis- Returns:
- this
-
rotate
Description copied from interface:Matrix3fc
Apply rotation to this matrix by rotating the given amount of radians about the given axis specified as x, y and z components, and store the result indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the rotation will be applied first!Reference: http://en.wikipedia.org
-
rotateLocal
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 indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Specified by:
rotateLocal
in interfaceMatrix3fc
- Parameters:
ang
- 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 result- Returns:
- dest
- See Also:
-
rotateLocal
Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified(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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Parameters:
ang
- the angle in radiansx
- the x component of the axisy
- the y component of the axisz
- the z component of the axis- Returns:
- this
- See Also:
-
rotateLocalX
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 indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Specified by:
rotateLocalX
in interfaceMatrix3fc
- Parameters:
ang
- the angle in radians to rotate about the X axisdest
- will hold the result- Returns:
- dest
- See Also:
-
rotateLocalX
Pre-multiply a rotation to this matrix by rotating the given amount of 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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Parameters:
ang
- the angle in radians to rotate about the X axis- Returns:
- this
- See Also:
-
rotateLocalY
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 indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Specified by:
rotateLocalY
in interfaceMatrix3fc
- Parameters:
ang
- the angle in radians to rotate about the Y axisdest
- will hold the result- Returns:
- dest
- See Also:
-
rotateLocalY
Pre-multiply a rotation to this matrix by rotating the given amount of radians about the Y 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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Parameters:
ang
- the angle in radians to rotate about the Y axis- Returns:
- this
- See Also:
-
rotateLocalZ
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 indest
.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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Specified by:
rotateLocalZ
in interfaceMatrix3fc
- Parameters:
ang
- the angle in radians to rotate about the Z axisdest
- will hold the result- Returns:
- dest
- See Also:
-
rotateLocalZ
Pre-multiply a rotation to this matrix by rotating the given amount of 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
isthis
matrix andR
the rotation matrix, then the new matrix will beR * M
. So when transforming a vectorv
with the new matrix by usingR * 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
- Parameters:
ang
- the angle in radians to rotate about the Z axis- Returns:
- this
- See Also:
-
rotate
Apply the rotation - and possibly scaling - transformation of the givenQuaternionfc
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
isthis
matrix andQ
the rotation matrix obtained from the given quaternion, then the new matrix will beM * Q
. So when transforming a vectorv
with the new matrix by usingM * 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
- Parameters:
quat
- theQuaternionfc
- Returns:
- this
- See Also:
-
rotate
Apply the rotation - and possibly scaling - transformation of the givenQuaternionfc
to this matrix and store the result indest
.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
isthis
matrix andQ
the rotation matrix obtained from the given quaternion, then the new matrix will beM * Q
. So when transforming a vectorv
with the new matrix by usingM * 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
- Specified by:
rotate
in interfaceMatrix3fc
- Parameters:
quat
- theQuaternionfc
dest
- will hold the result- Returns:
- dest
- See Also:
-
rotateLocal
Pre-multiply the rotation - and possibly scaling - transformation of the givenQuaternionfc
to this matrix and store the result indest
.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
isthis
matrix andQ
the rotation matrix obtained from the given quaternion, then the new matrix will beQ * M
. So when transforming a vectorv
with the new matrix by usingQ * 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
- Specified by:
rotateLocal
in interfaceMatrix3fc
- Parameters:
quat
- theQuaternionfc
dest
- will hold the result- Returns:
- dest
- See Also:
-
rotateLocal
Pre-multiply the rotation - and possibly scaling - transformation of the givenQuaternionfc
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
isthis
matrix andQ
the rotation matrix obtained from the given quaternion, then the new matrix will beQ * M
. So when transforming a vectorv
with the new matrix by usingQ * 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
- Parameters:
quat
- theQuaternionfc
- Returns:
- this
- See Also:
-
rotate
Apply a rotation transformation, rotating about the givenAxisAngle4f
, 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
isthis
matrix andA
the rotation matrix obtained from the givenAxisAngle4f
, then the new matrix will beM * A
. So when transforming a vectorv
with the new matrix by usingM * A * v
, theAxisAngle4f
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
- Parameters:
axisAngle
- theAxisAngle4f
(needs to benormalized
)- Returns:
- this
- See Also:
-
rotate
Apply a rotation transformation, rotating about the givenAxisAngle4f
and store the result indest
.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
isthis
matrix andA
the rotation matrix obtained from the givenAxisAngle4f
, then the new matrix will beM * A
. So when transforming a vectorv
with the new matrix by usingM * A * v
, theAxisAngle4f
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
- Specified by:
rotate
in interfaceMatrix3fc
- Parameters:
axisAngle
- theAxisAngle4f
(needs to benormalized
)dest
- will hold the result- Returns:
- dest
- See Also:
-
rotate
Apply a rotation transformation, rotating the given radians about the specified axis, 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
isthis
matrix andA
the rotation matrix obtained from the given angle and axis, then the new matrix will beM * A
. So when transforming a vectorv
with the new matrix by usingM * 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
- Parameters:
angle
- the angle in radiansaxis
- the rotation axis (needs to benormalized
)- Returns:
- this
- See Also:
-
rotate
Apply a rotation transformation, rotating the given radians about the specified axis and store the result indest
.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
isthis
matrix andA
the rotation matrix obtained from the given angle and axis, then the new matrix will beM * A
. So when transforming a vectorv
with the new matrix by usingM * 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
- Specified by:
rotate
in interfaceMatrix3fc
- Parameters:
angle
- the angle in radiansaxis
- the rotation axis (needs to benormalized
)dest
- will hold the result- Returns:
- dest
- See Also:
-
lookAlong
Apply a rotation transformation to this matrix to make-z
point alongdir
.If
M
isthis
matrix andL
the lookalong rotation matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * L * v
, the lookalong rotation transformation will be applied first!In order to set the matrix to a lookalong transformation without post-multiplying it, use
setLookAlong()
.- Parameters:
dir
- the direction in space to look alongup
- the direction of 'up'- Returns:
- this
- See Also:
-
lookAlong
Apply a rotation transformation to this matrix to make-z
point alongdir
and store the result indest
.If
M
isthis
matrix andL
the lookalong rotation matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * L * v
, the lookalong rotation transformation will be applied first!In order to set the matrix to a lookalong transformation without post-multiplying it, use
setLookAlong()
. -
lookAlong
public Matrix3f lookAlong(float dirX, float dirY, float dirZ, float upX, float upY, float upZ, Matrix3f dest) Apply a rotation transformation to this matrix to make-z
point alongdir
and store the result indest
.If
M
isthis
matrix andL
the lookalong rotation matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * L * v
, the lookalong rotation transformation will be applied first!In order to set the matrix to a lookalong transformation without post-multiplying it, use
setLookAlong()
- Specified by:
lookAlong
in interfaceMatrix3fc
- Parameters:
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 vectordest
- will hold the result- Returns:
- dest
- See Also:
-
lookAlong
Apply a rotation transformation to this matrix to make-z
point alongdir
.If
M
isthis
matrix andL
the lookalong rotation matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * L * v
, the lookalong rotation transformation will be applied first!In order to set the matrix to a lookalong transformation without post-multiplying it, use
setLookAlong()
- Parameters:
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 vector- Returns:
- this
- See Also:
-
setLookAlong
Set this matrix to a rotation transformation to make-z
point alongdir
.In order to apply the lookalong transformation to any previous existing transformation, use
lookAlong(Vector3fc, Vector3fc)
.- Parameters:
dir
- the direction in space to look alongup
- the direction of 'up'- Returns:
- this
- See Also:
-
setLookAlong
Set this matrix to a rotation transformation to make-z
point alongdir
.In order to apply the lookalong transformation to any previous existing transformation, use
lookAlong()
- Parameters:
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 vector- Returns:
- this
- See Also:
-
getRow
Description copied from interface:Matrix3fc
Get the row at the givenrow
index, starting with0
.- Specified by:
getRow
in interfaceMatrix3fc
- Parameters:
row
- the row index in[0..2]
dest
- will hold the row components- Returns:
- the passed in destination
- Throws:
IndexOutOfBoundsException
- ifrow
is not in[0..2]
-
setRow
Set the row at the givenrow
index, starting with0
.- Parameters:
row
- the row index in[0..2]
src
- the row components to set- Returns:
- this
- Throws:
IndexOutOfBoundsException
- ifrow
is not in[0..2]
-
setRow
Set the row at the givenrow
index, starting with0
.- Parameters:
row
- the row index in[0..2]
x
- the first element in the rowy
- the second element in the rowz
- the third element in the row- Returns:
- this
- Throws:
IndexOutOfBoundsException
- ifrow
is not in[0..2]
-
getColumn
Description copied from interface:Matrix3fc
Get the column at the givencolumn
index, starting with0
.- Specified by:
getColumn
in interfaceMatrix3fc
- Parameters:
column
- the column index in[0..2]
dest
- will hold the column components- Returns:
- the passed in destination
- Throws:
IndexOutOfBoundsException
- ifcolumn
is not in[0..2]
-
setColumn
Set the column at the givencolumn
index, starting with0
.- Parameters:
column
- the column index in[0..2]
src
- the column components to set- Returns:
- this
- Throws:
IndexOutOfBoundsException
- ifcolumn
is not in[0..2]
-
setColumn
Set the column at the givencolumn
index, starting with0
.- Parameters:
column
- the column index in[0..2]
x
- the first element in the columny
- the second element in the columnz
- the third element in the column- Returns:
- this
- Throws:
IndexOutOfBoundsException
- ifcolumn
is not in[0..2]
-
get
public float get(int column, int row) Description copied from interface:Matrix3fc
Get the matrix element value at the given column and row. -
set
Set the matrix element at the given column and row to the specified value.- Parameters:
column
- the colum index in[0..2]
row
- the row index in[0..2]
value
- the value- Returns:
- this
-
getRowColumn
public float getRowColumn(int row, int column) Description copied from interface:Matrix3fc
Get the matrix element value at the given row and column.- Specified by:
getRowColumn
in interfaceMatrix3fc
- Parameters:
row
- the row index in[0..2]
column
- the colum index in[0..2]
- Returns:
- the element value
-
setRowColumn
Set the matrix element at the given row and column to the specified value.- Parameters:
row
- the row index in[0..2]
column
- the colum index in[0..2]
value
- the value- Returns:
- this
-
normal
Setthis
matrix to its own normal matrix.The normal matrix of
m
is the transpose of the inverse ofm
.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 casethis
itself is its normal matrix. In this case, useset(Matrix3fc)
to set a given Matrix3f to this matrix.- Returns:
- this
- See Also:
-
normal
Compute a normal matrix fromthis
matrix and store it intodest
.The normal matrix of
m
is the transpose of the inverse ofm
.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 casethis
itself is its normal matrix. In this case, useset(Matrix3fc)
to set a given Matrix3f to this matrix. -
cofactor
Compute the cofactor matrix ofthis
.The cofactor matrix can be used instead of
normal()
to transform normals when the orientation of the normals with respect to the surface should be preserved.- Returns:
- this
-
cofactor
Compute the cofactor matrix ofthis
and store it intodest
.The cofactor matrix can be used instead of
normal(Matrix3f)
to transform normals when the orientation of the normals with respect to the surface should be preserved. -
getScale
Description copied from interface:Matrix3fc
Get the scaling factors ofthis
matrix for the three base axes. -
positiveZ
Description copied from interface:Matrix3fc
Obtain the direction of+Z
before the transformation represented bythis
matrix is applied.This method is equivalent to the following code:
Matrix3f inv = new Matrix3f(this).invert(); inv.transform(dir.set(0, 0, 1)).normalize();
Ifthis
is already an orthogonal matrix, then consider usingMatrix3fc.normalizedPositiveZ(Vector3f)
instead.Reference: http://www.euclideanspace.com
-
normalizedPositiveZ
Description copied from interface:Matrix3fc
Obtain the direction of+Z
before the transformation represented bythis
orthogonal matrix is applied. This method only produces correct results ifthis
is an orthogonal matrix.This method is equivalent to the following code:
Matrix3f inv = new Matrix3f(this).transpose(); inv.transform(dir.set(0, 0, 1));
Reference: http://www.euclideanspace.com
- Specified by:
normalizedPositiveZ
in interfaceMatrix3fc
- Parameters:
dir
- will hold the direction of+Z
- Returns:
- dir
-
positiveX
Description copied from interface:Matrix3fc
Obtain the direction of+X
before the transformation represented bythis
matrix is applied.This method is equivalent to the following code:
Matrix3f inv = new Matrix3f(this).invert(); inv.transform(dir.set(1, 0, 0)).normalize();
Ifthis
is already an orthogonal matrix, then consider usingMatrix3fc.normalizedPositiveX(Vector3f)
instead.Reference: http://www.euclideanspace.com
-
normalizedPositiveX
Description copied from interface:Matrix3fc
Obtain the direction of+X
before the transformation represented bythis
orthogonal matrix is applied. This method only produces correct results ifthis
is an orthogonal matrix.This method is equivalent to the following code:
Matrix3f inv = new Matrix3f(this).transpose(); inv.transform(dir.set(1, 0, 0));
Reference: http://www.euclideanspace.com
- Specified by:
normalizedPositiveX
in interfaceMatrix3fc
- Parameters:
dir
- will hold the direction of+X
- Returns:
- dir
-
positiveY
Description copied from interface:Matrix3fc
Obtain the direction of+Y
before the transformation represented bythis
matrix is applied.This method is equivalent to the following code:
Matrix3f inv = new Matrix3f(this).invert(); inv.transform(dir.set(0, 1, 0)).normalize();
Ifthis
is already an orthogonal matrix, then consider usingMatrix3fc.normalizedPositiveY(Vector3f)
instead.Reference: http://www.euclideanspace.com
-
normalizedPositiveY
Description copied from interface:Matrix3fc
Obtain the direction of+Y
before the transformation represented bythis
orthogonal matrix is applied. This method only produces correct results ifthis
is an orthogonal matrix.This method is equivalent to the following code:
Matrix3f inv = new Matrix3f(this).transpose(); inv.transform(dir.set(0, 1, 0));
Reference: http://www.euclideanspace.com
- Specified by:
normalizedPositiveY
in interfaceMatrix3fc
- Parameters:
dir
- will hold the direction of+Y
- Returns:
- dir
-
hashCode
public int hashCode() -
equals
-
equals
Description copied from interface:Matrix3fc
Compare the matrix elements ofthis
matrix with the given matrix using the givendelta
and return whether all of them are equal within a maximum difference ofdelta
.Please note that this method is not used by any data structure such as
ArrayList
HashSet
orHashMap
and their operations, such asArrayList.contains(Object)
orHashSet.remove(Object)
, since those data structures only use theObject.equals(Object)
andObject.hashCode()
methods. -
swap
Exchange the values ofthis
matrix with the givenother
matrix.- Parameters:
other
- the other matrix to exchange the values with- Returns:
- this
-
add
Component-wise addthis
andother
.- Parameters:
other
- the other addend- Returns:
- this
-
add
Description copied from interface:Matrix3fc
Component-wise addthis
andother
and store the result indest
. -
sub
Component-wise subtractsubtrahend
fromthis
.- Parameters:
subtrahend
- the subtrahend- Returns:
- this
-
sub
Description copied from interface:Matrix3fc
Component-wise subtractsubtrahend
fromthis
and store the result indest
. -
mulComponentWise
Component-wise multiplythis
byother
.- Parameters:
other
- the other matrix- Returns:
- this
-
mulComponentWise
Description copied from interface:Matrix3fc
Component-wise multiplythis
byother
and store the result indest
.- Specified by:
mulComponentWise
in interfaceMatrix3fc
- Parameters:
other
- the other matrixdest
- will hold the result- Returns:
- dest
-
setSkewSymmetric
Set this matrix to a skew-symmetric matrix using the following layout:0, a, -b -a, 0, c b, -c, 0
Reference: https://en.wikipedia.org- Parameters:
a
- the value used for the matrix elements m01 and m10b
- the value used for the matrix elements m02 and m20c
- the value used for the matrix elements m12 and m21- Returns:
- this
-
lerp
Linearly interpolatethis
andother
using the given interpolation factort
and store the result inthis
.If
t
is0.0
then the result isthis
. If the interpolation factor is1.0
then the result isother
.- Parameters:
other
- the other matrixt
- the interpolation factor between 0.0 and 1.0- Returns:
- this
-
lerp
Description copied from interface:Matrix3fc
Linearly interpolatethis
andother
using the given interpolation factort
and store the result indest
.If
t
is0.0
then the result isthis
. If the interpolation factor is1.0
then the result isother
. -
rotateTowards
Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdirection
and store the result indest
.If
M
isthis
matrix andL
the lookat matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * 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:
mul(new Matrix3f().lookAlong(new Vector3f(dir).negate(), up).invert(), dest)
- Specified by:
rotateTowards
in interfaceMatrix3fc
- Parameters:
direction
- the direction to rotate towardsup
- the model's up vectordest
- will hold the result- Returns:
- dest
- See Also:
-
rotateTowards
Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdirection
.If
M
isthis
matrix andL
the lookat matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * 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:
mul(new Matrix3f().lookAlong(new Vector3f(dir).negate(), up).invert())
- Parameters:
direction
- the direction to orient towardsup
- the up vector- Returns:
- this
- See Also:
-
rotateTowards
Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdirection
.If
M
isthis
matrix andL
the lookat matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * 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:
mul(new Matrix3f().lookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert())
- Parameters:
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 vector- Returns:
- this
- See Also:
-
rotateTowards
public Matrix3f rotateTowards(float dirX, float dirY, float dirZ, float upX, float upY, float upZ, Matrix3f dest) Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local+Z
axis withdir
and store the result indest
.If
M
isthis
matrix andL
the lookat matrix, then the new matrix will beM * L
. So when transforming a vectorv
with the new matrix by usingM * 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:
mul(new Matrix3f().lookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert(), dest)
- Specified by:
rotateTowards
in interfaceMatrix3fc
- Parameters:
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 vectordest
- will hold the result- Returns:
- dest
- See Also:
-
rotationTowards
Set this matrix to a model transformation for a right-handed coordinate system, that aligns the local-z
axis withcenter - eye
.In order to apply the rotation transformation to a previous existing transformation, use
rotateTowards
.This method is equivalent to calling:
setLookAlong(new Vector3f(dir).negate(), up).invert()
- Parameters:
dir
- the direction to orient the local -z axis towardsup
- the up vector- Returns:
- this
- See Also:
-
rotationTowards
public Matrix3f 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 withcenter - eye
.In order to apply the rotation transformation to a previous existing transformation, use
rotateTowards
.This method is equivalent to calling:
setLookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert()
- Parameters:
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 vector- Returns:
- this
- See Also:
-
getEulerAnglesZYX
Description copied from interface:Matrix3fc
Extract the Euler angles from the rotation represented bythis
matrix and store the extracted Euler angles indest
.This method assumes that
this
matrix only represents a rotation without scaling.The Euler angles are always returned as the angle around X in the
Vector3f.x
field, the angle around Y in theVector3f.y
field and the angle around Z in theVector3f.z
field of the suppliedVector3f
instance.Note that the returned Euler angles must be applied in the order
Z * Y * X
to obtain the identical matrix. This means that callingMatrix3fc.rotateZYX(float, float, float, Matrix3f)
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 matrixm2
should be identical tom
(disregarding possible floating-point inaccuracies).Matrix3f m = ...; // <- matrix only representing rotation Matrix3f n = new Matrix3f(); n.rotateZYX(m.getEulerAnglesZYX(new Vector3f()));
Reference: http://en.wikipedia.org/
- Specified by:
getEulerAnglesZYX
in interfaceMatrix3fc
- Parameters:
dest
- will hold the extracted Euler angles- Returns:
- dest
-
getEulerAnglesXYZ
Description copied from interface:Matrix3fc
Extract the Euler angles from the rotation represented bythis
matrix and store the extracted Euler angles indest
.This method assumes that
this
matrix only represents a rotation without scaling.The Euler angles are always returned as the angle around X in the
Vector3f.x
field, the angle around Y in theVector3f.y
field and the angle around Z in theVector3f.z
field of the suppliedVector3f
instance.Note that the returned Euler angles must be applied in the order
X * Y * Z
to obtain the identical matrix. This means that callingMatrix3fc.rotateXYZ(float, float, float, Matrix3f)
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 matrixm2
should be identical tom
(disregarding possible floating-point inaccuracies).Matrix3f m = ...; // <- matrix only representing rotation Matrix3f n = new Matrix3f(); n.rotateXYZ(m.getEulerAnglesXYZ(new Vector3f()));
Reference: http://en.wikipedia.org/
- Specified by:
getEulerAnglesXYZ
in interfaceMatrix3fc
- Parameters:
dest
- will hold the extracted Euler angles- Returns:
- dest
-
obliqueZ
Apply an oblique projection transformation to this matrix with the given values fora
andb
.If
M
isthis
matrix andO
the oblique transformation matrix, then the new matrix will beM * O
. So when transforming a vectorv
with the new matrix by usingM * O * v
, the oblique transformation will be applied first!The oblique transformation is defined as:
x' = x + a*z y' = y + a*z z' = z
or in matrix form:1 0 a 0 1 b 0 0 1
- Parameters:
a
- the value for the z factor that applies to xb
- the value for the z factor that applies to y- Returns:
- this
-
obliqueZ
Apply an oblique projection transformation to this matrix with the given values fora
andb
and store the result indest
.If
M
isthis
matrix andO
the oblique transformation matrix, then the new matrix will beM * O
. So when transforming a vectorv
with the new matrix by usingM * O * v
, the oblique transformation will be applied first!The oblique transformation is defined as:
x' = x + a*z y' = y + a*z z' = z
or in matrix form:1 0 a 0 1 b 0 0 1
-
reflect
Description copied from interface:Matrix3fc
Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal(nx, ny, nz)
, and store the result indest
.If
M
isthis
matrix andR
the reflection matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the reflection will be applied first! -
reflect
Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal.If
M
isthis
matrix andR
the reflection matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the reflection will be applied first!- Parameters:
nx
- the x-coordinate of the plane normalny
- the y-coordinate of the plane normalnz
- the z-coordinate of the plane normal- Returns:
- this
-
reflect
Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal.If
M
isthis
matrix andR
the reflection matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the reflection will be applied first!- Parameters:
normal
- the plane normal- Returns:
- this
-
reflect
Apply a mirror/reflection transformation to this matrix that reflects about a plane specified via the plane orientation.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 givenQuaternionfc
is the identity (does not apply any additional rotation), the reflection plane will bez=0
.If
M
isthis
matrix andR
the reflection matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the reflection will be applied first!- Parameters:
orientation
- the plane orientation- Returns:
- this
-
reflect
Description copied from interface:Matrix3fc
Apply a mirror/reflection transformation to this matrix that reflects through a plane specified via the plane orientation, and store the result indest
.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 givenQuaternionfc
is the identity (does not apply any additional rotation), the reflection plane will bez=0
.If
M
isthis
matrix andR
the reflection matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the reflection will be applied first! -
reflect
Description copied from interface:Matrix3fc
Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal, and store the result indest
.If
M
isthis
matrix andR
the reflection matrix, then the new matrix will beM * R
. So when transforming a vectorv
with the new matrix by usingM * R * v
, the reflection will be applied first! -
reflection
Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.- Parameters:
nx
- the x-coordinate of the plane normalny
- the y-coordinate of the plane normalnz
- the z-coordinate of the plane normal- Returns:
- this
-
reflection
Set this matrix to a mirror/reflection transformation that reflects through the given plane specified via the plane normal.- Parameters:
normal
- the plane normal- Returns:
- this
-
reflection
Set this matrix to a mirror/reflection transformation that reflects through a plane specified via the plane orientation.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 givenQuaternionfc
is the identity (does not apply any additional rotation), the reflection plane will bez=0
, offset by the givenpoint
.- Parameters:
orientation
- the plane orientation- Returns:
- this
-
isFinite
public boolean isFinite()Description copied from interface:Matrix3fc
-
quadraticFormProduct
public float quadraticFormProduct(float x, float y, float z) Description copied from interface:Matrix3fc
Compute(x, y, z)^T * this * (x, y, z)
.- Specified by:
quadraticFormProduct
in interfaceMatrix3fc
- Parameters:
x
- the x coordinate of the vector to multiplyy
- the y coordinate of the vector to multiplyz
- the z coordinate of the vector to multiply- Returns:
- the result
-
quadraticFormProduct
Description copied from interface:Matrix3fc
Computev^T * this * v
.- Specified by:
quadraticFormProduct
in interfaceMatrix3fc
- Parameters:
v
- the vector to multiply- Returns:
- the result
-
mapXZY
Multiplythis
by the matrix1 0 0 0 0 1 0 1 0
- Returns:
- this
-
mapXZY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 0 1 0 1 0
and store the result indest
. -
mapXZnY
Multiplythis
by the matrix1 0 0 0 0 -1 0 1 0
- Returns:
- this
-
mapXZnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 0 -1 0 1 0
and store the result indest
. -
mapXnYnZ
Multiplythis
by the matrix1 0 0 0 -1 0 0 0 -1
- Returns:
- this
-
mapXnYnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 -1 0 0 0 -1
and store the result indest
. -
mapXnZY
Multiplythis
by the matrix1 0 0 0 0 1 0 -1 0
- Returns:
- this
-
mapXnZY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 0 1 0 -1 0
and store the result indest
. -
mapXnZnY
Multiplythis
by the matrix1 0 0 0 0 -1 0 -1 0
- Returns:
- this
-
mapXnZnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 0 -1 0 -1 0
and store the result indest
. -
mapYXZ
Multiplythis
by the matrix0 1 0 1 0 0 0 0 1
- Returns:
- this
-
mapYXZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 1 0 0 0 0 1
and store the result indest
. -
mapYXnZ
Multiplythis
by the matrix0 1 0 1 0 0 0 0 -1
- Returns:
- this
-
mapYXnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 1 0 0 0 0 -1
and store the result indest
. -
mapYZX
Multiplythis
by the matrix0 0 1 1 0 0 0 1 0
- Returns:
- this
-
mapYZX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 1 0 0 0 1 0
and store the result indest
. -
mapYZnX
Multiplythis
by the matrix0 0 -1 1 0 0 0 1 0
- Returns:
- this
-
mapYZnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 1 0 0 0 1 0
and store the result indest
. -
mapYnXZ
Multiplythis
by the matrix0 -1 0 1 0 0 0 0 1
- Returns:
- this
-
mapYnXZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 1 0 0 0 0 1
and store the result indest
. -
mapYnXnZ
Multiplythis
by the matrix0 -1 0 1 0 0 0 0 -1
- Returns:
- this
-
mapYnXnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 1 0 0 0 0 -1
and store the result indest
. -
mapYnZX
Multiplythis
by the matrix0 0 1 1 0 0 0 -1 0
- Returns:
- this
-
mapYnZX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 1 0 0 0 -1 0
and store the result indest
. -
mapYnZnX
Multiplythis
by the matrix0 0 -1 1 0 0 0 -1 0
- Returns:
- this
-
mapYnZnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 1 0 0 0 -1 0
and store the result indest
. -
mapZXY
Multiplythis
by the matrix0 1 0 0 0 1 1 0 0
- Returns:
- this
-
mapZXY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 0 0 1 1 0 0
and store the result indest
. -
mapZXnY
Multiplythis
by the matrix0 1 0 0 0 -1 1 0 0
- Returns:
- this
-
mapZXnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 0 0 -1 1 0 0
and store the result indest
. -
mapZYX
Multiplythis
by the matrix0 0 1 0 1 0 1 0 0
- Returns:
- this
-
mapZYX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 0 1 0 1 0 0
and store the result indest
. -
mapZYnX
Multiplythis
by the matrix0 0 -1 0 1 0 1 0 0
- Returns:
- this
-
mapZYnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 0 1 0 1 0 0
and store the result indest
. -
mapZnXY
Multiplythis
by the matrix0 -1 0 0 0 1 1 0 0
- Returns:
- this
-
mapZnXY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 0 0 1 1 0 0
and store the result indest
. -
mapZnXnY
Multiplythis
by the matrix0 -1 0 0 0 -1 1 0 0
- Returns:
- this
-
mapZnXnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 0 0 -1 1 0 0
and store the result indest
. -
mapZnYX
Multiplythis
by the matrix0 0 1 0 -1 0 1 0 0
- Returns:
- this
-
mapZnYX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 0 -1 0 1 0 0
and store the result indest
. -
mapZnYnX
Multiplythis
by the matrix0 0 -1 0 -1 0 1 0 0
- Returns:
- this
-
mapZnYnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 0 -1 0 1 0 0
and store the result indest
. -
mapnXYnZ
Multiplythis
by the matrix-1 0 0 0 1 0 0 0 -1
- Returns:
- this
-
mapnXYnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 1 0 0 0 -1
and store the result indest
. -
mapnXZY
Multiplythis
by the matrix-1 0 0 0 0 1 0 1 0
- Returns:
- this
-
mapnXZY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 0 1 0 1 0
and store the result indest
. -
mapnXZnY
Multiplythis
by the matrix-1 0 0 0 0 -1 0 1 0
- Returns:
- this
-
mapnXZnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 0 -1 0 1 0
and store the result indest
. -
mapnXnYZ
Multiplythis
by the matrix-1 0 0 0 -1 0 0 0 1
- Returns:
- this
-
mapnXnYZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 -1 0 0 0 1
and store the result indest
. -
mapnXnYnZ
Multiplythis
by the matrix-1 0 0 0 -1 0 0 0 -1
- Returns:
- this
-
mapnXnYnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 -1 0 0 0 -1
and store the result indest
. -
mapnXnZY
Multiplythis
by the matrix-1 0 0 0 0 1 0 -1 0
- Returns:
- this
-
mapnXnZY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 0 1 0 -1 0
and store the result indest
. -
mapnXnZnY
Multiplythis
by the matrix-1 0 0 0 0 -1 0 -1 0
- Returns:
- this
-
mapnXnZnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 0 -1 0 -1 0
and store the result indest
. -
mapnYXZ
Multiplythis
by the matrix0 1 0 -1 0 0 0 0 1
- Returns:
- this
-
mapnYXZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 -1 0 0 0 0 1
and store the result indest
. -
mapnYXnZ
Multiplythis
by the matrix0 1 0 -1 0 0 0 0 -1
- Returns:
- this
-
mapnYXnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 -1 0 0 0 0 -1
and store the result indest
. -
mapnYZX
Multiplythis
by the matrix0 0 1 -1 0 0 0 1 0
- Returns:
- this
-
mapnYZX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 -1 0 0 0 1 0
and store the result indest
. -
mapnYZnX
Multiplythis
by the matrix0 0 -1 -1 0 0 0 1 0
- Returns:
- this
-
mapnYZnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 -1 0 0 0 1 0
and store the result indest
. -
mapnYnXZ
Multiplythis
by the matrix0 -1 0 -1 0 0 0 0 1
- Returns:
- this
-
mapnYnXZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 -1 0 0 0 0 1
and store the result indest
. -
mapnYnXnZ
Multiplythis
by the matrix0 -1 0 -1 0 0 0 0 -1
- Returns:
- this
-
mapnYnXnZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 -1 0 0 0 0 -1
and store the result indest
. -
mapnYnZX
Multiplythis
by the matrix0 0 1 -1 0 0 0 -1 0
- Returns:
- this
-
mapnYnZX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 -1 0 0 0 -1 0
and store the result indest
. -
mapnYnZnX
Multiplythis
by the matrix0 0 -1 -1 0 0 0 -1 0
- Returns:
- this
-
mapnYnZnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 -1 0 0 0 -1 0
and store the result indest
. -
mapnZXY
Multiplythis
by the matrix0 1 0 0 0 1 -1 0 0
- Returns:
- this
-
mapnZXY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 0 0 1 -1 0 0
and store the result indest
. -
mapnZXnY
Multiplythis
by the matrix0 1 0 0 0 -1 -1 0 0
- Returns:
- this
-
mapnZXnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 1 0 0 0 -1 -1 0 0
and store the result indest
. -
mapnZYX
Multiplythis
by the matrix0 0 1 0 1 0 -1 0 0
- Returns:
- this
-
mapnZYX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 0 1 0 -1 0 0
and store the result indest
. -
mapnZYnX
Multiplythis
by the matrix0 0 -1 0 1 0 -1 0 0
- Returns:
- this
-
mapnZYnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 0 1 0 -1 0 0
and store the result indest
. -
mapnZnXY
Multiplythis
by the matrix0 -1 0 0 0 1 -1 0 0
- Returns:
- this
-
mapnZnXY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 0 0 1 -1 0 0
and store the result indest
. -
mapnZnXnY
Multiplythis
by the matrix0 -1 0 0 0 -1 -1 0 0
- Returns:
- this
-
mapnZnXnY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 -1 0 0 0 -1 -1 0 0
and store the result indest
. -
mapnZnYX
Multiplythis
by the matrix0 0 1 0 -1 0 -1 0 0
- Returns:
- this
-
mapnZnYX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 1 0 -1 0 -1 0 0
and store the result indest
. -
mapnZnYnX
Multiplythis
by the matrix0 0 -1 0 -1 0 -1 0 0
- Returns:
- this
-
mapnZnYnX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix0 0 -1 0 -1 0 -1 0 0
and store the result indest
. -
negateX
Multiplythis
by the matrix-1 0 0 0 1 0 0 0 1
- Returns:
- this
-
negateX
Description copied from interface:Matrix3fc
Multiplythis
by the matrix-1 0 0 0 1 0 0 0 1
and store the result indest
. -
negateY
Multiplythis
by the matrix1 0 0 0 -1 0 0 0 1
- Returns:
- this
-
negateY
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 -1 0 0 0 1
and store the result indest
. -
negateZ
Multiplythis
by the matrix1 0 0 0 1 0 0 0 -1
- Returns:
- this
-
negateZ
Description copied from interface:Matrix3fc
Multiplythis
by the matrix1 0 0 0 1 0 0 0 -1
and store the result indest
. -
clone
- Overrides:
clone
in classObject
- Throws:
CloneNotSupportedException
-