Matrix3dc (JOML 1.9.18 API)

All Known Implementing Classes:

Matrix3d, Matrix3dStack
```
public interface Matrix3dc
```
Interface to a read-only view of a 3x3 matrix of double-precision floats.

Author:

Kai Burjack

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Matrix3d`	`add(Matrix3dc other, Matrix3d dest)` Component-wise add `this` and `other` and store the result in `dest`.
`Matrix3d`	`cofactor(Matrix3d dest)` Compute the cofactor matrix of `this` and store it into `dest`.
`double`	`determinant()` Return the determinant of this matrix.
`boolean`	`equals(Matrix3dc m, double delta)` Compare the matrix elements of `this` matrix with the given matrix using the given `delta` and return whether all of them are equal within a maximum difference of `delta`.
`ByteBuffer`	`get(ByteBuffer buffer)` Store this matrix in column-major order into the supplied `ByteBuffer` at the current buffer `position`.
`double[]`	`get(double[] arr)` Store this matrix into the supplied double array in column-major order.
`double[]`	`get(double[] arr, int offset)` Store this matrix into the supplied double array in column-major order at the given offset.
`DoubleBuffer`	`get(DoubleBuffer buffer)` Store this matrix into the supplied `DoubleBuffer` at the current buffer `position` using column-major order.
`float[]`	`get(float[] arr)` Store the elements of this matrix as float values in column-major order into the supplied float array.
`float[]`	`get(float[] arr, int offset)` Store the elements of this matrix as float values in column-major order into the supplied float array at the given offset.
`FloatBuffer`	`get(FloatBuffer buffer)` Store this matrix in column-major order into the supplied `FloatBuffer` at the current buffer `position`.
`ByteBuffer`	`get(int index, ByteBuffer buffer)` Store this matrix in column-major order into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`DoubleBuffer`	`get(int index, DoubleBuffer buffer)` Store this matrix into the supplied `DoubleBuffer` starting at the specified absolute buffer position/index using column-major order.
`FloatBuffer`	`get(int index, FloatBuffer buffer)` Store this matrix in column-major order into the supplied `FloatBuffer` starting at the specified absolute buffer position/index.
`double`	`get(int column, int row)` Get the matrix element value at the given column and row.
`Matrix3d`	`get(Matrix3d dest)` Get the current values of `this` matrix and store them into `dest`.
`Vector3d`	`getColumn(int column, Vector3d dest)` Get the column at the given `column` index, starting with `0`.
`Vector3d`	`getEulerAnglesZYX(Vector3d dest)` Extract the Euler angles from the rotation represented by `this` matrix and store the extracted Euler angles in `dest`.
`ByteBuffer`	`getFloats(ByteBuffer buffer)` Store the elements of this matrix as float values in column-major order into the supplied `ByteBuffer` at the current buffer `position`.
`ByteBuffer`	`getFloats(int index, ByteBuffer buffer)` Store the elements of this matrix as float values in column-major order into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`Quaterniond`	`getNormalizedRotation(Quaterniond dest)` Get the current values of `this` matrix and store the represented rotation into the given `Quaterniond`.
`Quaternionf`	`getNormalizedRotation(Quaternionf dest)` Get the current values of `this` matrix and store the represented rotation into the given `Quaternionf`.
`AxisAngle4f`	`getRotation(AxisAngle4f dest)` Get the current values of `this` matrix and store the represented rotation into the given `AxisAngle4f`.
`Vector3d`	`getRow(int row, Vector3d dest)` Get the row at the given `row` index, starting with `0`.
`Vector3d`	`getScale(Vector3d dest)` Get the scaling factors of `this` matrix for the three base axes.
`Quaterniond`	`getUnnormalizedRotation(Quaterniond dest)` Get the current values of `this` matrix and store the represented rotation into the given `Quaterniond`.
`Quaternionf`	`getUnnormalizedRotation(Quaternionf dest)` Get the current values of `this` matrix and store the represented rotation into the given `Quaternionf`.
`Matrix3d`	`invert(Matrix3d dest)` Invert `this` matrix and store the result in `dest`.
`Matrix3d`	`lerp(Matrix3dc other, double t, Matrix3d dest)` Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.
`Matrix3d`	`lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix3d dest)` Apply a rotation transformation to this matrix to make `-z` point along `dir` and store the result in `dest`.
`Matrix3d`	`lookAlong(Vector3dc dir, Vector3dc up, Matrix3d dest)` Apply a rotation transformation to this matrix to make `-z` point along `dir` and store the result in `dest`.
`double`	`m00()` Return the value of the matrix element at column 0 and row 0.
`double`	`m01()` Return the value of the matrix element at column 0 and row 1.
`double`	`m02()` Return the value of the matrix element at column 0 and row 2.
`double`	`m10()` Return the value of the matrix element at column 1 and row 0.
`double`	`m11()` Return the value of the matrix element at column 1 and row 1.
`double`	`m12()` Return the value of the matrix element at column 1 and row 2.
`double`	`m20()` Return the value of the matrix element at column 2 and row 0.
`double`	`m21()` Return the value of the matrix element at column 2 and row 1.
`double`	`m22()` Return the value of the matrix element at column 2 and row 2.
`Matrix3d`	`mul(Matrix3dc right, Matrix3d dest)` Multiply this matrix by the supplied matrix and store the result in `dest`.
`Matrix3d`	`mul(Matrix3fc right, Matrix3d dest)` Multiply this matrix by the supplied matrix and store the result in `dest`.
`Matrix3d`	`mulComponentWise(Matrix3dc other, Matrix3d dest)` Component-wise multiply `this` by `other` and store the result in `dest`.
`Matrix3d`	`mulLocal(Matrix3dc left, Matrix3d dest)` Pre-multiply this matrix by the supplied `left` matrix and store the result in `dest`.
`Matrix3d`	`normal(Matrix3d dest)` Compute a normal matrix from `this` matrix and store it into `dest`.
`Vector3d`	`normalizedPositiveX(Vector3d dir)` Obtain the direction of `+X` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	`normalizedPositiveY(Vector3d dir)` Obtain the direction of `+Y` before the transformation represented by `this` orthogonal matrix is applied.
`Vector3d`	`normalizedPositiveZ(Vector3d dir)` Obtain the direction of `+Z` before the transformation represented by `this` orthogonal matrix is applied.
`Matrix3d`	`obliqueZ(double a, double b, Matrix3d dest)` Apply an oblique projection transformation to this matrix with the given values for `a` and `b` and store the result in `dest`.
`Vector3d`	`positiveX(Vector3d dir)` Obtain the direction of `+X` before the transformation represented by `this` matrix is applied.
`Vector3d`	`positiveY(Vector3d dir)` Obtain the direction of `+Y` before the transformation represented by `this` matrix is applied.
`Vector3d`	`positiveZ(Vector3d dir)` Obtain the direction of `+Z` before the transformation represented by `this` matrix is applied.
`Matrix3d`	`reflect(double nx, double ny, double nz, Matrix3d dest)` 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 in `dest`.
`Matrix3d`	`reflect(Quaterniondc orientation, Matrix3d dest)` Apply a mirror/reflection transformation to this matrix that reflects through a plane specified via the plane orientation, and store the result in `dest`.
`Matrix3d`	`reflect(Vector3dc normal, Matrix3d dest)` Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal, and store the result in `dest`.
`Matrix3d`	`rotate(AxisAngle4d axisAngle, Matrix3d dest)` Apply a rotation transformation, rotating about the given `AxisAngle4d` and store the result in `dest`.
`Matrix3d`	`rotate(AxisAngle4f axisAngle, Matrix3d dest)` Apply a rotation transformation, rotating about the given `AxisAngle4f` and store the result in `dest`.
`Matrix3d`	`rotate(double ang, double x, double y, double z, Matrix3d dest)` 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 in `dest`.
`Matrix3d`	`rotate(double angle, Vector3dc axis, Matrix3d dest)` Apply a rotation transformation, rotating the given radians about the specified axis and store the result in `dest`.
`Matrix3d`	`rotate(double angle, Vector3fc axis, Matrix3d dest)` Apply a rotation transformation, rotating the given radians about the specified axis and store the result in `dest`.
`Matrix3d`	`rotate(Quaterniondc quat, Matrix3d dest)` Apply the rotation - and possibly scaling - transformation of the given `Quaterniondc` to this matrix and store the result in `dest`.
`Matrix3d`	`rotate(Quaternionfc quat, Matrix3d dest)` Apply the rotation - and possibly scaling - transformation of the given `Quaternionfc` to this matrix and store the result in `dest`.
`Matrix3d`	`rotateLocal(double ang, double x, double y, double z, Matrix3d dest)` Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified `(x, y, z)` axis and store the result in `dest`.
`Matrix3d`	`rotateLocal(Quaterniondc quat, Matrix3d dest)` Pre-multiply the rotation - and possibly scaling - transformation of the given `Quaterniondc` to this matrix and store the result in `dest`.
`Matrix3d`	`rotateLocal(Quaternionfc quat, Matrix3d dest)` Pre-multiply the rotation - and possibly scaling - transformation of the given `Quaternionfc` to this matrix and store the result in `dest`.
`Matrix3d`	`rotateLocalX(double ang, Matrix3d dest)` Pre-multiply a rotation around the X axis to this matrix by rotating the given amount of radians about the X axis and store the result in `dest`.
`Matrix3d`	`rotateLocalY(double ang, Matrix3d dest)` Pre-multiply a rotation around the Y axis to this matrix by rotating the given amount of radians about the Y axis and store the result in `dest`.
`Matrix3d`	`rotateLocalZ(double ang, Matrix3d dest)` Pre-multiply a rotation around the Z axis to this matrix by rotating the given amount of radians about the Z axis and store the result in `dest`.
`Matrix3d`	`rotateTowards(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Matrix3d dest)` Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local `+Z` axis with `dir` and store the result in `dest`.
`Matrix3d`	`rotateTowards(Vector3dc direction, Vector3dc up, Matrix3d dest)` Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local `+Z` axis with `direction` and store the result in `dest`.
`Matrix3d`	`rotateX(double ang, Matrix3d dest)` Apply rotation about the X axis to this matrix by rotating the given amount of radians and store the result in `dest`.
`Matrix3d`	`rotateXYZ(double angleX, double angleY, double angleZ, Matrix3d dest)` Apply rotation of `angleX` radians about the X axis, followed by a rotation of `angleY` radians about the Y axis and followed by a rotation of `angleZ` radians about the Z axis and store the result in `dest`.
`Matrix3d`	`rotateY(double ang, Matrix3d dest)` Apply rotation about the Y axis to this matrix by rotating the given amount of radians and store the result in `dest`.
`Matrix3d`	`rotateYXZ(double angleY, double angleX, double angleZ, Matrix3d dest)` Apply rotation of `angleY` radians about the Y axis, followed by a rotation of `angleX` radians about the X axis and followed by a rotation of `angleZ` radians about the Z axis and store the result in `dest`.
`Matrix3d`	`rotateZ(double ang, Matrix3d dest)` Apply rotation about the Z axis to this matrix by rotating the given amount of radians and store the result in `dest`.
`Matrix3d`	`rotateZYX(double angleZ, double angleY, double angleX, Matrix3d dest)` Apply rotation of `angleZ` radians about the Z axis, followed by a rotation of `angleY` radians about the Y axis and followed by a rotation of `angleX` radians about the X axis and store the result in `dest`.
`Matrix3d`	`scale(double x, double y, double z, Matrix3d dest)` Apply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in `dest`.
`Matrix3d`	`scale(double xyz, Matrix3d dest)` Apply scaling to this matrix by uniformly scaling all base axes by the given `xyz` factor and store the result in `dest`.
`Matrix3d`	`scale(Vector3dc xyz, Matrix3d dest)` Apply scaling to `this` matrix by scaling the base axes by the given `xyz.x`, `xyz.y` and `xyz.z` factors, respectively and store the result in `dest`.
`Matrix3d`	`scaleLocal(double x, double y, double z, Matrix3d dest)` Pre-multiply scaling to `this` matrix by scaling the base axes by the given x, y and z factors and store the result in `dest`.
`Matrix3d`	`sub(Matrix3dc subtrahend, Matrix3d dest)` Component-wise subtract `subtrahend` from `this` and store the result in `dest`.
`Vector3d`	`transform(double x, double y, double z, Vector3d dest)` Transform the vector `(x, y, z)` by this matrix and store the result in `dest`.
`Vector3d`	`transform(Vector3d v)` Transform the given vector by this matrix.
`Vector3d`	`transform(Vector3dc v, Vector3d dest)` Transform the given vector by this matrix and store the result in `dest`.
`Vector3f`	`transform(Vector3f v)` Transform the given vector by this matrix.
`Vector3f`	`transform(Vector3fc v, Vector3f dest)` Transform the given vector by this matrix and store the result in `dest`.
`Vector3d`	`transformTranspose(double x, double y, double z, Vector3d dest)` Transform the vector `(x, y, z)` by the transpose of this matrix and store the result in `dest`.
`Vector3d`	`transformTranspose(Vector3d v)` Transform the given vector by the transpose of this matrix.
`Vector3d`	`transformTranspose(Vector3dc v, Vector3d dest)` Transform the given vector by the transpose of this matrix and store the result in `dest`.
`Matrix3d`	`transpose(Matrix3d dest)` Transpose `this` matrix and store the result in `dest`.

- Method Detail
  - m00
```
double m00()
```
    Return the value of the matrix element at column 0 and row 0.
    
    Returns:
    
    the value of the matrix element
  - m01
```
double m01()
```
    Return the value of the matrix element at column 0 and row 1.
    
    Returns:
    
    the value of the matrix element
  - m02
```
double m02()
```
    Return the value of the matrix element at column 0 and row 2.
    
    Returns:
    
    the value of the matrix element
  - m10
```
double m10()
```
    Return the value of the matrix element at column 1 and row 0.
    
    Returns:
    
    the value of the matrix element
  - m11
```
double m11()
```
    Return the value of the matrix element at column 1 and row 1.
    
    Returns:
    
    the value of the matrix element
  - m12
```
double m12()
```
    Return the value of the matrix element at column 1 and row 2.
    
    Returns:
    
    the value of the matrix element
  - m20
```
double m20()
```
    Return the value of the matrix element at column 2 and row 0.
    
    Returns:
    
    the value of the matrix element
  - m21
```
double m21()
```
    Return the value of the matrix element at column 2 and row 1.
    
    Returns:
    
    the value of the matrix element
  - m22
```
double m22()
```
    Return the value of the matrix element at column 2 and row 2.
    
    Returns:
    
    the value of the matrix element
  - mul
```
Matrix3d mul(Matrix3dc right,
             Matrix3d dest)
```
    Multiply this matrix by the supplied matrix and store the result in dest. This matrix will be the left one.
    If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!
    
    Parameters:
    
    right - the right operand
    
    dest - will hold the result
    
    Returns:
    
    dest
  - mulLocal
```
Matrix3d mulLocal(Matrix3dc left,
                  Matrix3d dest)
```
    Pre-multiply this matrix by the supplied left matrix and store the result in dest.
    If M is this matrix and L the left matrix, then the new matrix will be L * M. So when transforming a vector v with the new matrix by using L * M * v, the transformation of this matrix will be applied first!
    
    Parameters:
    
    left - the left operand of the matrix multiplication
    
    dest - the destination matrix, which will hold the result
    
    Returns:
    
    dest
  - mul
```
Matrix3d mul(Matrix3fc right,
             Matrix3d dest)
```
    Multiply this matrix by the supplied matrix and store the result in dest. This matrix will be the left one.
    If M is this matrix and R the right matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the transformation of the right matrix will be applied first!
    
    Parameters:
    
    right - the right operand
    
    dest - will hold the result
    
    Returns:
    
    dest
  - determinant
```
double determinant()
```
    Return the determinant of this matrix.
    
    Returns:
    
    the determinant
  - invert
```
Matrix3d invert(Matrix3d dest)
```
    Invert this matrix and store the result in dest.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transpose
```
Matrix3d transpose(Matrix3d dest)
```
    Transpose this matrix and store the result in dest.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - get
```
Matrix3d get(Matrix3d dest)
```
    Get the current values of this matrix and store them into dest.
    
    Parameters:
    
    dest - the destination matrix
    
    Returns:
    
    the passed in destination
  - getRotation
```
AxisAngle4f getRotation(AxisAngle4f dest)
```
    Get the current values of this matrix and store the represented rotation into the given AxisAngle4f.
    
    Parameters:
    
    dest - the destination AxisAngle4f
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    AxisAngle4f.set(Matrix3dc)
  - getUnnormalizedRotation
```
Quaternionf getUnnormalizedRotation(Quaternionf dest)
```
    Get the current values of this matrix and store the represented rotation into the given Quaternionf.
    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.
    
    Parameters:
    
    dest - the destination Quaternionf
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Quaternionf.setFromUnnormalized(Matrix3dc)
  - getNormalizedRotation
```
Quaternionf getNormalizedRotation(Quaternionf dest)
```
    Get the current values of this matrix and store the represented rotation into the given Quaternionf.
    This method assumes that the three column vectors of this matrix are normalized.
    
    Parameters:
    
    dest - the destination Quaternionf
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Quaternionf.setFromNormalized(Matrix3dc)
  - getUnnormalizedRotation
```
Quaterniond getUnnormalizedRotation(Quaterniond dest)
```
    Get the current values of this matrix and store the represented rotation into the given Quaterniond.
    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.
    
    Parameters:
    
    dest - the destination Quaterniond
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Quaterniond.setFromUnnormalized(Matrix3dc)
  - getNormalizedRotation
```
Quaterniond getNormalizedRotation(Quaterniond dest)
```
    Get the current values of this matrix and store the represented rotation into the given Quaterniond.
    This method assumes that the three column vectors of this matrix are normalized.
    
    Parameters:
    
    dest - the destination Quaterniond
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Quaterniond.setFromNormalized(Matrix3dc)
  - get
```
DoubleBuffer get(DoubleBuffer buffer)
```
    Store this matrix into the supplied DoubleBuffer at the current buffer position using column-major order.
    This method will not increment the position of the given DoubleBuffer.
    In order to specify the offset into the DoubleBuffer} at which the matrix is stored, use get(int, DoubleBuffer), taking the absolute position as parameter.
    
    Parameters:
    
    buffer - will receive the values of this matrix in column-major order at its current position
    
    Returns:
    
    the passed in buffer
    
    See Also:
    
    get(int, DoubleBuffer)
  - get
```
DoubleBuffer get(int index,
                 DoubleBuffer buffer)
```
    Store this matrix into the supplied DoubleBuffer starting at the specified absolute buffer position/index using column-major order.
    This method will not increment the position of the given DoubleBuffer.
    
    Parameters:
    
    index - the absolute position into the DoubleBuffer
    
    buffer - will receive the values of this matrix in column-major order
    
    Returns:
    
    the passed in buffer
  - get
```
FloatBuffer get(FloatBuffer buffer)
```
    Store this matrix in column-major order into the supplied FloatBuffer at the current buffer position.
    This method will not increment the position of the given FloatBuffer.
    In order to specify the offset into the FloatBuffer at which the matrix is stored, use get(int, FloatBuffer), taking the absolute position as parameter.
    Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.
    
    Parameters:
    
    buffer - will receive the values of this matrix in column-major order at its current position
    
    Returns:
    
    the passed in buffer
    
    See Also:
    
    get(int, FloatBuffer)
  - get
```
FloatBuffer get(int index,
                FloatBuffer buffer)
```
    Store this matrix in column-major order into the supplied FloatBuffer starting at the specified absolute buffer position/index.
    This method will not increment the position of the given FloatBuffer.
    Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given FloatBuffer.
    
    Parameters:
    
    index - the absolute position into the FloatBuffer
    
    buffer - will receive the values of this matrix in column-major order
    
    Returns:
    
    the passed in buffer
  - get
```
ByteBuffer get(ByteBuffer buffer)
```
    Store this matrix in column-major order into the supplied ByteBuffer at the current buffer position.
    This method will not increment the position of the given ByteBuffer.
    In order to specify the offset into the ByteBuffer at which the matrix is stored, use get(int, ByteBuffer), taking the absolute position as parameter.
    
    Parameters:
    
    buffer - will receive the values of this matrix in column-major order at its current position
    
    Returns:
    
    the passed in buffer
    
    See Also:
    
    get(int, ByteBuffer)
  - get
```
ByteBuffer get(int index,
               ByteBuffer buffer)
```
    Store this matrix in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
    This method will not increment the position of the given ByteBuffer.
    
    Parameters:
    
    index - the absolute position into the ByteBuffer
    
    buffer - will receive the values of this matrix in column-major order
    
    Returns:
    
    the passed in buffer
  - getFloats
```
ByteBuffer getFloats(ByteBuffer buffer)
```
    Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer at the current buffer position.
    This method will not increment the position of the given ByteBuffer.
    Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given ByteBuffer.
    In order to specify the offset into the ByteBuffer at which the matrix is stored, use getFloats(int, ByteBuffer), taking the absolute position as parameter.
    
    Parameters:
    
    buffer - will receive the elements of this matrix as float values in column-major order at its current position
    
    Returns:
    
    the passed in buffer
    
    See Also:
    
    getFloats(int, ByteBuffer)
  - getFloats
```
ByteBuffer getFloats(int index,
                     ByteBuffer buffer)
```
    Store the elements of this matrix as float values in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.
    This method will not increment the position of the given ByteBuffer.
    Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given ByteBuffer.
    
    Parameters:
    
    index - the absolute position into the ByteBuffer
    
    buffer - will receive the elements of this matrix as float values in column-major order
    
    Returns:
    
    the passed in buffer
  - get
```
double[] get(double[] arr,
             int offset)
```
    Store this matrix into the supplied double array in column-major order at the given offset.
    
    Parameters:
    
    arr - the array to write the matrix values into
    
    offset - the offset into the array
    
    Returns:
    
    the passed in array
  - get
```
double[] get(double[] arr)
```
    Store this matrix into the supplied double array in column-major order.
    In order to specify an explicit offset into the array, use the method get(double[], int).
    
    Parameters:
    
    arr - the array to write the matrix values into
    
    Returns:
    
    the passed in array
    
    See Also:
    
    get(double[], int)
  - get
```
float[] get(float[] arr,
            int offset)
```
    Store the elements of this matrix as float values in column-major order into the supplied float array at the given offset.
    Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given float array.
    
    Parameters:
    
    arr - the array to write the matrix values into
    
    offset - the offset into the array
    
    Returns:
    
    the passed in array
  - get
```
float[] get(float[] arr)
```
    Store the elements of this matrix as float values in column-major order into the supplied float array.
    Please note that due to this matrix storing double values those values will potentially lose precision when they are converted to float values before being put into the given float array.
    In order to specify an explicit offset into the array, use the method get(float[], int).
    
    Parameters:
    
    arr - the array to write the matrix values into
    
    Returns:
    
    the passed in array
    
    See Also:
    
    get(float[], int)
  - scale
```
Matrix3d scale(Vector3dc xyz,
               Matrix3d dest)
```
    Apply scaling to this matrix by scaling the base axes by the given xyz.x, xyz.y and xyz.z factors, respectively and store the result in dest.
    If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!
    
    Parameters:
    
    xyz - the factors of the x, y and z component, respectively
    
    dest - will hold the result
    
    Returns:
    
    dest
  - scale
```
Matrix3d scale(double x,
               double y,
               double z,
               Matrix3d dest)
```
    Apply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in dest.
    If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!
    
    Parameters:
    
    x - the factor of the x component
    
    y - the factor of the y component
    
    z - the factor of the z component
    
    dest - will hold the result
    
    Returns:
    
    dest
  - scale
```
Matrix3d scale(double xyz,
               Matrix3d dest)
```
    Apply scaling to this matrix by uniformly scaling all base axes by the given xyz factor and store the result in dest.
    If M is this matrix and S the scaling matrix, then the new matrix will be M * S. So when transforming a vector v with the new matrix by using M * S * v , the scaling will be applied first!
    
    Parameters:
    
    xyz - the factor for all components
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    scale(double, double, double, Matrix3d)
  - scaleLocal
```
Matrix3d scaleLocal(double x,
                    double y,
                    double z,
                    Matrix3d dest)
```
    Pre-multiply scaling to this matrix by scaling the base axes by the given x, y and z factors and store the result in dest.
    If M is this matrix and S the scaling matrix, then the new matrix will be S * M. So when transforming a vector v with the new matrix by using S * M * v , the scaling will be applied last!
    
    Parameters:
    
    x - the factor of the x component
    
    y - the factor of the y component
    
    z - the factor of the z component
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
Vector3d transform(Vector3d v)
```
    Transform the given vector by this matrix.
    
    Parameters:
    
    v - the vector to transform
    
    Returns:
    
    v
  - transform
```
Vector3d transform(Vector3dc v,
                   Vector3d dest)
```
    Transform the given vector by this matrix and store the result in dest.
    
    Parameters:
    
    v - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
Vector3f transform(Vector3f v)
```
    Transform the given vector by this matrix.
    
    Parameters:
    
    v - the vector to transform
    
    Returns:
    
    v
  - transform
```
Vector3f transform(Vector3fc v,
                   Vector3f dest)
```
    Transform the given vector by this matrix and store the result in dest.
    
    Parameters:
    
    v - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
Vector3d transform(double x,
                   double y,
                   double z,
                   Vector3d dest)
```
    Transform the vector (x, y, z) by this matrix and store the result in dest.
    
    Parameters:
    
    x - the x coordinate of the vector to transform
    
    y - the y coordinate of the vector to transform
    
    z - the z coordinate of the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transformTranspose
```
Vector3d transformTranspose(Vector3d v)
```
    Transform the given vector by the transpose of this matrix.
    
    Parameters:
    
    v - the vector to transform
    
    Returns:
    
    v
  - transformTranspose
```
Vector3d transformTranspose(Vector3dc v,
                            Vector3d dest)
```
    Transform the given vector by the transpose of this matrix and store the result in dest.
    
    Parameters:
    
    v - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transformTranspose
```
Vector3d transformTranspose(double x,
                            double y,
                            double z,
                            Vector3d dest)
```
    Transform the vector (x, y, z) by the transpose of this matrix and store the result in dest.
    
    Parameters:
    
    x - the x coordinate of the vector to transform
    
    y - the y coordinate of the vector to transform
    
    z - the z coordinate of the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateX
```
Matrix3d rotateX(double ang,
                 Matrix3d dest)
```
    Apply rotation about the X axis to this matrix by rotating the given amount of radians and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateY
```
Matrix3d rotateY(double ang,
                 Matrix3d dest)
```
    Apply rotation about the Y axis to this matrix by rotating the given amount of radians and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateZ
```
Matrix3d rotateZ(double ang,
                 Matrix3d dest)
```
    Apply rotation about the Z axis to this matrix by rotating the given amount of radians and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateXYZ
```
Matrix3d rotateXYZ(double angleX,
                   double angleY,
                   double angleZ,
                   Matrix3d dest)
```
    Apply rotation of angleX radians about the X axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleZ radians about the Z axis and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!
    This method is equivalent to calling: rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)
    
    Parameters:
    
    angleX - the angle to rotate about X
    
    angleY - the angle to rotate about Y
    
    angleZ - the angle to rotate about Z
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateZYX
```
Matrix3d rotateZYX(double angleZ,
                   double angleY,
                   double angleX,
                   Matrix3d dest)
```
    Apply rotation of angleZ radians about the Z axis, followed by a rotation of angleY radians about the Y axis and followed by a rotation of angleX radians about the X axis and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!
    This method is equivalent to calling: rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)
    
    Parameters:
    
    angleZ - the angle to rotate about Z
    
    angleY - the angle to rotate about Y
    
    angleX - the angle to rotate about X
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateYXZ
```
Matrix3d rotateYXZ(double angleY,
                   double angleX,
                   double angleZ,
                   Matrix3d dest)
```
    Apply rotation of angleY radians about the Y axis, followed by a rotation of angleX radians about the X axis and followed by a rotation of angleZ radians about the Z axis and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the rotation will be applied first!
    This method is equivalent to calling: rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)
    
    Parameters:
    
    angleY - the angle to rotate about Y
    
    angleX - the angle to rotate about X
    
    angleZ - the angle to rotate about Z
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotate
```
Matrix3d rotate(double ang,
                double x,
                double y,
                double z,
                Matrix3d dest)
```
    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 in dest.
    The axis described by the three components needs to be a unit vector.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v , the rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians
    
    x - the x component of the axis
    
    y - the y component of the axis
    
    z - the z component of the axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocal
```
Matrix3d rotateLocal(double ang,
                     double x,
                     double y,
                     double z,
                     Matrix3d dest)
```
    Pre-multiply a rotation to this matrix by rotating the given amount of radians about the specified (x, y, z) axis and store the result in dest.
    The axis described by the three components needs to be a unit vector.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians
    
    x - the x component of the axis
    
    y - the y component of the axis
    
    z - the z component of the axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalX
```
Matrix3d rotateLocalX(double ang,
                      Matrix3d dest)
```
    Pre-multiply a rotation around the X axis to this matrix by rotating the given amount of radians about the X axis and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians to rotate about the X axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalY
```
Matrix3d rotateLocalY(double ang,
                      Matrix3d dest)
```
    Pre-multiply a rotation around the Y axis to this matrix by rotating the given amount of radians about the Y axis and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians to rotate about the Y axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalZ
```
Matrix3d rotateLocalZ(double ang,
                      Matrix3d dest)
```
    Pre-multiply a rotation around the Z axis to this matrix by rotating the given amount of radians about the Z axis and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and R the rotation matrix, then the new matrix will be R * M. So when transforming a vector v with the new matrix by using R * M * v, the rotation will be applied last!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    ang - the angle in radians to rotate about the Z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocal
```
Matrix3d rotateLocal(Quaterniondc quat,
                     Matrix3d dest)
```
    Pre-multiply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be Q * M. So when transforming a vector v with the new matrix by using Q * M * v, the quaternion rotation will be applied last!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    quat - the Quaterniondc
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocal
```
Matrix3d rotateLocal(Quaternionfc quat,
                     Matrix3d dest)
```
    Pre-multiply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be Q * M. So when transforming a vector v with the new matrix by using Q * M * v, the quaternion rotation will be applied last!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    quat - the Quaternionfc
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotate
```
Matrix3d rotate(Quaterniondc quat,
                Matrix3d dest)
```
    Apply the rotation - and possibly scaling - transformation of the given Quaterniondc to this matrix and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be M * Q. So when transforming a vector v with the new matrix by using M * Q * v, the quaternion rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    quat - the Quaterniondc
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotate
```
Matrix3d rotate(Quaternionfc quat,
                Matrix3d dest)
```
    Apply the rotation - and possibly scaling - transformation of the given Quaternionfc to this matrix and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and Q the rotation matrix obtained from the given quaternion, then the new matrix will be M * Q. So when transforming a vector v with the new matrix by using M * Q * v, the quaternion rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    quat - the Quaternionfc
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotate
```
Matrix3d rotate(AxisAngle4f axisAngle,
                Matrix3d dest)
```
    Apply a rotation transformation, rotating about the given AxisAngle4f and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and A the rotation matrix obtained from the given AxisAngle4f, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the AxisAngle4f rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    axisAngle - the AxisAngle4f (needs to be normalized)
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, double, Matrix3d)
  - rotate
```
Matrix3d rotate(AxisAngle4d axisAngle,
                Matrix3d dest)
```
    Apply a rotation transformation, rotating about the given AxisAngle4d and store the result in dest.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and A the rotation matrix obtained from the given AxisAngle4d, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the AxisAngle4d rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    axisAngle - the AxisAngle4d (needs to be normalized)
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, double, Matrix3d)
  - rotate
```
Matrix3d rotate(double angle,
                Vector3dc axis,
                Matrix3d dest)
```
    Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
    The axis described by the axis vector needs to be a unit vector.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and A the rotation matrix obtained from the given axis and angle, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the axis-angle rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    angle - the angle in radians
    
    axis - the rotation axis (needs to be normalized)
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, double, Matrix3d)
  - rotate
```
Matrix3d rotate(double angle,
                Vector3fc axis,
                Matrix3d dest)
```
    Apply a rotation transformation, rotating the given radians about the specified axis and store the result in dest.
    The axis described by the axis vector needs to be a unit vector.
    When used with a right-handed coordinate system, the produced rotation will rotate a vector counter-clockwise around the rotation axis, when viewing along the negative axis direction towards the origin. When used with a left-handed coordinate system, the rotation is clockwise.
    If M is this matrix and A the rotation matrix obtained from the given axis and angle, then the new matrix will be M * A. So when transforming a vector v with the new matrix by using M * A * v, the axis-angle rotation will be applied first!
    Reference: http://en.wikipedia.org
    
    Parameters:
    
    angle - the angle in radians
    
    axis - the rotation axis (needs to be normalized)
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, double, Matrix3d)
  - getRow
```
Vector3d getRow(int row,
                Vector3d dest)
         throws IndexOutOfBoundsException
```
    Get the row at the given row index, starting with 0.
    
    Parameters:
    
    row - the row index in [0..2]
    
    dest - will hold the row components
    
    Returns:
    
    the passed in destination
    
    Throws:
    
    IndexOutOfBoundsException - if row is not in [0..2]
  - getColumn
```
Vector3d getColumn(int column,
                   Vector3d dest)
            throws IndexOutOfBoundsException
```
    Get the column at the given column index, starting with 0.
    
    Parameters:
    
    column - the column index in [0..2]
    
    dest - will hold the column components
    
    Returns:
    
    the passed in destination
    
    Throws:
    
    IndexOutOfBoundsException - if column is not in [0..2]
  - get
```
double get(int column,
           int row)
```
    Get the matrix element value at the given column and row.
    
    Parameters:
    
    column - the colum index in [0..2]
    
    row - the row index in [0..2]
    
    Returns:
    
    the element value
  - normal
```
Matrix3d normal(Matrix3d dest)
```
    Compute a normal matrix from this matrix and store it into dest.
    The normal matrix of m is the transpose of the inverse of m.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - cofactor
```
Matrix3d cofactor(Matrix3d dest)
```
    Compute the cofactor matrix of this and store it into dest.
    The cofactor matrix can be used instead of normal(Matrix3d) to transform normals when the orientation of the normals with respect to the surface should be preserved.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - lookAlong
```
Matrix3d lookAlong(Vector3dc dir,
                   Vector3dc up,
                   Matrix3d dest)
```
    Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
    If M is this matrix and L the lookalong rotation matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookalong rotation transformation will be applied first!
    
    Parameters:
    
    dir - the direction in space to look along
    
    up - the direction of 'up'
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    lookAlong(double, double, double, double, double, double, Matrix3d)
  - lookAlong
```
Matrix3d lookAlong(double dirX,
                   double dirY,
                   double dirZ,
                   double upX,
                   double upY,
                   double upZ,
                   Matrix3d dest)
```
    Apply a rotation transformation to this matrix to make -z point along dir and store the result in dest.
    If M is this matrix and L the lookalong rotation matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookalong rotation transformation will be applied first!
    
    Parameters:
    
    dirX - the x-coordinate of the direction to look along
    
    dirY - the y-coordinate of the direction to look along
    
    dirZ - the z-coordinate of the direction to look along
    
    upX - the x-coordinate of the up vector
    
    upY - the y-coordinate of the up vector
    
    upZ - the z-coordinate of the up vector
    
    dest - will hold the result
    
    Returns:
    
    dest
  - getScale
```
Vector3d getScale(Vector3d dest)
```
    Get the scaling factors of this matrix for the three base axes.
    
    Parameters:
    
    dest - will hold the scaling factors for x, y and z
    
    Returns:
    
    dest
  - positiveZ
```
Vector3d positiveZ(Vector3d dir)
```
    Obtain the direction of +Z before the transformation represented by this matrix is applied.
    This method is equivalent to the following code:
```
 Matrix3d inv = new Matrix3d(this).invert();
 inv.transform(dir.set(0, 0, 1)).normalize();
 
```
    If this is already an orthogonal matrix, then consider using normalizedPositiveZ(Vector3d) instead.
    Reference: http://www.euclideanspace.com
    Parameters:
    
    dir - will hold the direction of +Z
    
    Returns:
    
    dir
  - normalizedPositiveZ
```
Vector3d normalizedPositiveZ(Vector3d dir)
```
    Obtain the direction of +Z before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.
    This method is equivalent to the following code:
```
 Matrix3d inv = new Matrix3d(this).transpose();
 inv.transform(dir.set(0, 0, 1));
 
```
    Reference: http://www.euclideanspace.com
    Parameters:
    
    dir - will hold the direction of +Z
    
    Returns:
    
    dir
  - positiveX
```
Vector3d positiveX(Vector3d dir)
```
    Obtain the direction of +X before the transformation represented by this matrix is applied.
    This method is equivalent to the following code:
```
 Matrix3d inv = new Matrix3d(this).invert();
 inv.transform(dir.set(1, 0, 0)).normalize();
 
```
    If this is already an orthogonal matrix, then consider using normalizedPositiveX(Vector3d) instead.
    Reference: http://www.euclideanspace.com
    Parameters:
    
    dir - will hold the direction of +X
    
    Returns:
    
    dir
  - normalizedPositiveX
```
Vector3d normalizedPositiveX(Vector3d dir)
```
    Obtain the direction of +X before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.
    This method is equivalent to the following code:
```
 Matrix3d inv = new Matrix3d(this).transpose();
 inv.transform(dir.set(1, 0, 0));
 
```
    Reference: http://www.euclideanspace.com
    Parameters:
    
    dir - will hold the direction of +X
    
    Returns:
    
    dir
  - positiveY
```
Vector3d positiveY(Vector3d dir)
```
    Obtain the direction of +Y before the transformation represented by this matrix is applied.
    This method is equivalent to the following code:
```
 Matrix3d inv = new Matrix3d(this).invert();
 inv.transform(dir.set(0, 1, 0)).normalize();
 
```
    If this is already an orthogonal matrix, then consider using normalizedPositiveY(Vector3d) instead.
    Reference: http://www.euclideanspace.com
    Parameters:
    
    dir - will hold the direction of +Y
    
    Returns:
    
    dir
  - normalizedPositiveY
```
Vector3d normalizedPositiveY(Vector3d dir)
```
    Obtain the direction of +Y before the transformation represented by this orthogonal matrix is applied. This method only produces correct results if this is an orthogonal matrix.
    This method is equivalent to the following code:
```
 Matrix3d inv = new Matrix3d(this).transpose();
 inv.transform(dir.set(0, 1, 0));
 
```
    Reference: http://www.euclideanspace.com
    Parameters:
    
    dir - will hold the direction of +Y
    
    Returns:
    
    dir
  - add
```
Matrix3d add(Matrix3dc other,
             Matrix3d dest)
```
    Component-wise add this and other and store the result in dest.
    
    Parameters:
    
    other - the other addend
    
    dest - will hold the result
    
    Returns:
    
    dest
  - sub
```
Matrix3d sub(Matrix3dc subtrahend,
             Matrix3d dest)
```
    Component-wise subtract subtrahend from this and store the result in dest.
    
    Parameters:
    
    subtrahend - the subtrahend
    
    dest - will hold the result
    
    Returns:
    
    dest
  - mulComponentWise
```
Matrix3d mulComponentWise(Matrix3dc other,
                          Matrix3d dest)
```
    Component-wise multiply this by other and store the result in dest.
    
    Parameters:
    
    other - the other matrix
    
    dest - will hold the result
    
    Returns:
    
    dest
  - lerp
```
Matrix3d lerp(Matrix3dc other,
              double t,
              Matrix3d dest)
```
    Linearly interpolate this and other using the given interpolation factor t and store the result in dest.
    If t is 0.0 then the result is this. If the interpolation factor is 1.0 then the result is other.
    
    Parameters:
    
    other - the other matrix
    
    t - the interpolation factor between 0.0 and 1.0
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateTowards
```
Matrix3d rotateTowards(Vector3dc direction,
                       Vector3dc up,
                       Matrix3d dest)
```
    Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with direction and store the result in dest.
    If M is this matrix and L the lookat matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookat transformation will be applied first!
    This method is equivalent to calling: mul(new Matrix3d().lookAlong(new Vector3d(dir).negate(), up).invert(), dest)
    
    Parameters:
    
    direction - the direction to rotate towards
    
    up - the model's up vector
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateTowards(double, double, double, double, double, double, Matrix3d)
  - rotateTowards
```
Matrix3d rotateTowards(double dirX,
                       double dirY,
                       double dirZ,
                       double upX,
                       double upY,
                       double upZ,
                       Matrix3d dest)
```
    Apply a model transformation to this matrix for a right-handed coordinate system, that aligns the local +Z axis with dir and store the result in dest.
    If M is this matrix and L the lookat matrix, then the new matrix will be M * L. So when transforming a vector v with the new matrix by using M * L * v, the lookat transformation will be applied first!
    This method is equivalent to calling: mul(new Matrix3d().lookAlong(-dirX, -dirY, -dirZ, upX, upY, upZ).invert(), dest)
    
    Parameters:
    
    dirX - the x-coordinate of the direction to rotate towards
    
    dirY - the y-coordinate of the direction to rotate towards
    
    dirZ - the z-coordinate of the direction to rotate towards
    
    upX - the x-coordinate of the up vector
    
    upY - the y-coordinate of the up vector
    
    upZ - the z-coordinate of the up vector
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateTowards(Vector3dc, Vector3dc, Matrix3d)
  - getEulerAnglesZYX
```
Vector3d getEulerAnglesZYX(Vector3d dest)
```
    Extract the Euler angles from the rotation represented by this matrix and store the extracted Euler angles in dest.
    This method assumes that this matrix only represents a rotation without scaling.
    Note that the returned Euler angles must be applied in the order Z * Y * X to obtain the identical matrix. This means that calling rotateZYX(double, double, double, Matrix3d) using the obtained Euler angles will yield the same rotation as the original matrix from which the Euler angles were obtained, so in the below code the matrix m2 should be identical to m (disregarding possible floating-point inaccuracies).
```
 Matrix3d m = ...; // <- matrix only representing rotation
 Matrix3d n = new Matrix3d();
 n.rotateZYX(m.getEulerAnglesZYX(new Vector3d()));
 
```
    Reference: http://nghiaho.com/
    Parameters:
    
    dest - will hold the extracted Euler angles
    
    Returns:
    
    dest
  - obliqueZ
```
Matrix3d obliqueZ(double a,
                  double b,
                  Matrix3d dest)
```
    Apply an oblique projection transformation to this matrix with the given values for a and b and store the result in dest.
    If M is this matrix and O the oblique transformation matrix, then the new matrix will be M * O. So when transforming a vector v with the new matrix by using M * O * v, the oblique transformation will be applied first!
    The oblique transformation is defined as:
```
 x' = x + a*z
 y' = y + a*z
 z' = 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 x
    
    b - the value for the z factor that applies to y
    
    dest - will hold the result
    
    Returns:
    
    dest
  - equals
```
boolean equals(Matrix3dc m,
               double delta)
```
    Compare the matrix elements of this matrix with the given matrix using the given delta and return whether all of them are equal within a maximum difference of delta.
    Please note that this method is not used by any data structure such as ArrayList HashSet or HashMap and their operations, such as ArrayList.contains(Object) or HashSet.remove(Object), since those data structures only use the Object.equals(Object) and Object.hashCode() methods.
    
    Parameters:
    
    m - the other matrix
    
    delta - the allowed maximum difference
    
    Returns:
    
    true whether all of the matrix elements are equal; false otherwise
  - reflect
```
Matrix3d reflect(double nx,
                 double ny,
                 double nz,
                 Matrix3d dest)
```
    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 in dest.
    If M is this matrix and R the reflection matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the reflection will be applied first!
    
    Parameters:
    
    nx - the x-coordinate of the plane normal
    
    ny - the y-coordinate of the plane normal
    
    nz - the z-coordinate of the plane normal
    
    dest - will hold the result
    
    Returns:
    
    a matrix holding the result
  - reflect
```
Matrix3d reflect(Quaterniondc orientation,
                 Matrix3d dest)
```
    Apply a mirror/reflection transformation to this matrix that reflects through a plane specified via the plane orientation, and store the result in dest.
    This method can be used to build a reflection transformation based on the orientation of a mirror object in the scene. It is assumed that the default mirror plane's normal is (0, 0, 1). So, if the given Quaterniondc is the identity (does not apply any additional rotation), the reflection plane will be z=0.
    If M is this matrix and R the reflection matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the reflection will be applied first!
    
    Parameters:
    
    orientation - the plane orientation
    
    dest - will hold the result
    
    Returns:
    
    a matrix holding the result
  - reflect
```
Matrix3d reflect(Vector3dc normal,
                 Matrix3d dest)
```
    Apply a mirror/reflection transformation to this matrix that reflects through the given plane specified via the plane normal, and store the result in dest.
    If M is this matrix and R the reflection matrix, then the new matrix will be M * R. So when transforming a vector v with the new matrix by using M * R * v, the reflection will be applied first!
    
    Parameters:
    
    normal - the plane normal
    
    dest - will hold the result
    
    Returns:
    
    this

Interface Matrix3dc

Method Summary

Method Detail

m00

m01

m02

m10

m11

m12

m20

m21

m22

mul

mulLocal

mul

determinant

invert

transpose

get

getRotation

getUnnormalizedRotation

getNormalizedRotation

getUnnormalizedRotation

getNormalizedRotation

get

get

get

get

get

get

getFloats

getFloats

get

get

get

get

scale

scale

scale

scaleLocal

transform

transform

transform

transform

transform

transformTranspose

transformTranspose

transformTranspose

rotateX

rotateY

rotateZ

rotateXYZ

rotateZYX

rotateYXZ

rotate

rotateLocal

rotateLocalX

rotateLocalY

rotateLocalZ

rotateLocal

rotateLocal

rotate

rotate

rotate

rotate

rotate

rotate

getRow

getColumn

get

normal

cofactor

lookAlong

lookAlong

getScale

positiveZ

normalizedPositiveZ

positiveX

normalizedPositiveX

positiveY