Package org.joml

Interface Matrix3fc

All Known Implementing Classes:
Matrix3f, Matrix3fStack
public interface Matrix3fc
Interface to a read-only view of a 3x3 matrix of single-precision floats.
Author:
Kai Burjack

  • Method Details

    • m00

      float m00()
      Return the value of the matrix element at column 0 and row 0.
      Returns:
      the value of the matrix element

    • m01

      float m01()
      Return the value of the matrix element at column 0 and row 1.
      Returns:
      the value of the matrix element

    • m02

      float m02()
      Return the value of the matrix element at column 0 and row 2.
      Returns:
      the value of the matrix element

    • m10

      float m10()
      Return the value of the matrix element at column 1 and row 0.
      Returns:
      the value of the matrix element

    • m11

      float m11()
      Return the value of the matrix element at column 1 and row 1.
      Returns:
      the value of the matrix element

    • m12

      float m12()
      Return the value of the matrix element at column 1 and row 2.
      Returns:
      the value of the matrix element

    • m20

      float m20()
      Return the value of the matrix element at column 2 and row 0.
      Returns:
      the value of the matrix element

    • m21

      float m21()
      Return the value of the matrix element at column 2 and row 1.
      Returns:
      the value of the matrix element

    • m22

      float m22()
      Return the value of the matrix element at column 2 and row 2.
      Returns:
      the value of the matrix element

    • mul

      Matrix3f mul(Matrix3fc right, Matrix3f dest)
      Multiply this matrix by the supplied right matrix and store the result in dest.

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

      Parameters:
      right - the right operand of the matrix multiplication
      dest - will hold the result
      Returns:
      dest

    • mulLocal

      Matrix3f mulLocal(Matrix3fc left, Matrix3f 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

    • determinant

      float determinant()
      Return the determinant of this matrix.
      Returns:
      the determinant

    • invert

      Matrix3f invert(Matrix3f dest)
      Invert the this matrix and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • transpose

      Matrix3f transpose(Matrix3f dest)
      Transpose this matrix and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • get

      Matrix3f get(Matrix3f dest)
      Get the current values of this matrix and store them into dest.
      Parameters:
      dest - the destination matrix
      Returns:
      the passed in destination

    • get

      Matrix4f get(Matrix4f dest)
      Get the current values of this matrix and store them as the rotational component of dest. All other values of dest will be set to identity.
      Parameters:
      dest - the destination matrix
      Returns:
      the passed in destination
      See Also:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • get

      com.google.gwt.typedarrays.shared.Float32Array get(com.google.gwt.typedarrays.shared.Float32Array buffer)
      Store this matrix in column-major order into the supplied Float32Array.
      Parameters:
      buffer - will receive the values of this matrix in column-major order
      Returns:
      the passed in buffer

    • get

      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 supplied Float32Array at the given index.
      Parameters:
      index - the index at which to store this matrix in the supplied Float32Array
      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.

      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

      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.

      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

      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

    • get3x4

      FloatBuffer get3x4(FloatBuffer buffer)
      Store this matrix as 3x4 matrix in column-major order into the supplied FloatBuffer at the current buffer position, 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 get3x4(int, FloatBuffer), taking the absolute position as parameter.

      Parameters:
      buffer - will receive the values of this 3x3 matrix as 3x4 matrix in column-major order at its current position
      Returns:
      the passed in buffer
      See Also:

    • get3x4

      FloatBuffer get3x4(int index, FloatBuffer buffer)
      Store this matrix as 3x4 matrix in column-major order into the supplied FloatBuffer 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.

      Parameters:
      index - the absolute position into the FloatBuffer
      buffer - will receive the values of this 3x3 matrix as 3x4 matrix in column-major order
      Returns:
      the passed in buffer

    • get3x4

      ByteBuffer get3x4(ByteBuffer buffer)
      Store this matrix as 3x4 matrix in column-major order into the supplied ByteBuffer at the current buffer position, 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 get3x4(int, ByteBuffer), taking the absolute position as parameter.

      Parameters:
      buffer - will receive the values of this 3x3 matrix as 3x4 matrix in column-major order at its current position
      Returns:
      the passed in buffer
      See Also:

    • get3x4

      ByteBuffer get3x4(int index, ByteBuffer buffer)
      Store this matrix as 3x4 matrix in column-major order into the supplied ByteBuffer 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.

      Parameters:
      index - the absolute position into the ByteBuffer
      buffer - will receive the values of this 3x3 matrix as 3x4 matrix in column-major order
      Returns:
      the passed in buffer

    • getTransposed

      FloatBuffer getTransposed(FloatBuffer buffer)
      Store the transpose of 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 getTransposed(int, FloatBuffer), 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:

    • getTransposed

      FloatBuffer getTransposed(int index, FloatBuffer buffer)
      Store the transpose of this matrix in column-major order into the supplied FloatBuffer starting at the specified absolute buffer position/index.

      This method will not increment the position of 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

    • getTransposed

      ByteBuffer getTransposed(ByteBuffer buffer)
      Store the transpose of 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 getTransposed(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:

    • getTransposed

      ByteBuffer getTransposed(int index, ByteBuffer buffer)
      Store the transpose of this matrix in column-major order into the supplied ByteBuffer starting at the specified absolute buffer position/index.

      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

    • getToAddress

      Matrix3fc getToAddress(long address)
      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.

      Parameters:
      address - the off-heap address where to store this matrix
      Returns:
      this

    • get

      float[] get(float[] arr, int offset)
      Store this matrix into the supplied float 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

      float[] get(float[] arr)
      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 get(float[], int).

      Parameters:
      arr - the array to write the matrix values into
      Returns:
      the passed in array
      See Also:

    • scale

      Matrix3f scale(Vector3fc xyz, Matrix3f 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

      Matrix3f scale(float x, float y, float z, Matrix3f 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

      Matrix3f scale(float xyz, Matrix3f 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:

    • scaleLocal

      Matrix3f scaleLocal(float x, float y, float z, Matrix3f 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

      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

      Vector3f transform(float x, float y, float z, Vector3f 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

      Vector3f transformTranspose(Vector3f v)
      Transform the given vector by the transpose of this matrix.
      Parameters:
      v - the vector to transform
      Returns:
      v

    • transformTranspose

      Vector3f transformTranspose(Vector3fc v, Vector3f 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

      Vector3f 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 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

      Matrix3f rotateX(float ang, Matrix3f 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

      Matrix3f rotateY(float ang, Matrix3f 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

      Matrix3f rotateZ(float ang, Matrix3f 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

      Matrix3f rotateXYZ(float angleX, float angleY, float angleZ, Matrix3f 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

      Matrix3f rotateZYX(float angleZ, float angleY, float angleX, Matrix3f 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

      Matrix3f rotateYXZ(float angleY, float angleX, float angleZ, Matrix3f 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

      Matrix3f rotate(float ang, float x, float y, float z, Matrix3f 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

      Matrix3f 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 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

      Matrix3f 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 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

      Matrix3f 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 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

      Matrix3f 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 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

    • rotate

      Matrix3f rotate(Quaternionfc quat, Matrix3f 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

    • rotateLocal

      Matrix3f rotateLocal(Quaternionfc quat, Matrix3f 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

      Matrix3f rotate(AxisAngle4f axisAngle, Matrix3f 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

      Matrix3f rotate(float angle, Vector3fc axis, Matrix3f dest)
      Apply a rotation transformation, rotating the given radians about the specified 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 A the rotation matrix obtained from the given angle and axis, 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:

    • lookAlong

      Matrix3f lookAlong(Vector3fc dir, Vector3fc up, Matrix3f 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

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

    • getRow

      Vector3f getRow(int row, Vector3f 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

      Vector3f getColumn(int column, Vector3f 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

      float 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

    • getRowColumn

      float getRowColumn(int row, int column)
      Get the matrix element value at the given row and column.
      Parameters:
      row - the row index in [0..2]
      column - the colum index in [0..2]
      Returns:
      the element value

    • normal

      Matrix3f normal(Matrix3f 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

      Matrix3f cofactor(Matrix3f dest)
      Compute the cofactor matrix of this and store it into dest.

      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.

      Parameters:
      dest - will hold the result
      Returns:
      dest

    • getScale

      Vector3f getScale(Vector3f 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

      Vector3f positiveZ(Vector3f dir)
      Obtain the direction of +Z before the transformation represented by this 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();
      If this is already an orthogonal matrix, then consider using normalizedPositiveZ(Vector3f) instead.

      Reference: http://www.euclideanspace.com

      Parameters:
      dir - will hold the direction of +Z
      Returns:
      dir

    • normalizedPositiveZ

      Vector3f normalizedPositiveZ(Vector3f 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: 

       Matrix3f inv = new Matrix3f(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

      Vector3f positiveX(Vector3f dir)
      Obtain the direction of +X before the transformation represented by this 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();
      If this is already an orthogonal matrix, then consider using normalizedPositiveX(Vector3f) instead.

      Reference: http://www.euclideanspace.com

      Parameters:
      dir - will hold the direction of +X
      Returns:
      dir

    • normalizedPositiveX

      Vector3f normalizedPositiveX(Vector3f 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: 

       Matrix3f inv = new Matrix3f(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

      Vector3f positiveY(Vector3f dir)
      Obtain the direction of +Y before the transformation represented by this 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();
      If this is already an orthogonal matrix, then consider using normalizedPositiveY(Vector3f) instead.

      Reference: http://www.euclideanspace.com

      Parameters:
      dir - will hold the direction of +Y
      Returns:
      dir

    • normalizedPositiveY

      Vector3f normalizedPositiveY(Vector3f 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: 

       Matrix3f inv = new Matrix3f(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

      Matrix3f add(Matrix3fc other, Matrix3f 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

      Matrix3f sub(Matrix3fc subtrahend, Matrix3f 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

      Matrix3f mulComponentWise(Matrix3fc other, Matrix3f 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

      Matrix3f lerp(Matrix3fc other, float t, Matrix3f 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

      Matrix3f 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 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 Matrix3f().lookAlong(new Vector3f(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

      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 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 Matrix3f().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:

    • getEulerAnglesXYZ

      Vector3f getEulerAnglesXYZ(Vector3f 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.

      The Euler angles are always returned as the angle around X in the Vector3f.x field, the angle around Y in the Vector3f.y field and the angle around Z in the Vector3f.z field of the supplied Vector3f instance.

      Note that the returned Euler angles must be applied in the order X * Y * Z to obtain the identical matrix. This means that calling 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 matrix m2 should be identical to m (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/

      Parameters:
      dest - will hold the extracted Euler angles
      Returns:
      dest

    • getEulerAnglesZYX

      Vector3f getEulerAnglesZYX(Vector3f 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.

      The Euler angles are always returned as the angle around X in the Vector3f.x field, the angle around Y in the Vector3f.y field and the angle around Z in the Vector3f.z field of the supplied Vector3f instance.

      Note that the returned Euler angles must be applied in the order Z * Y * X to obtain the identical matrix. This means that calling rotateZYX(float, float, float, 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 matrix m2 should be identical to m (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/

      Parameters:
      dest - will hold the extracted Euler angles
      Returns:
      dest

    • obliqueZ

      Matrix3f obliqueZ(float a, float b, Matrix3f 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(Matrix3fc m, float delta)
      Compare the matrix elements of this matrix with the given matrix using the given delta and return whether all of them are equal within a maximum difference of delta.

      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

      Matrix3f reflect(float nx, float ny, float nz, Matrix3f 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:
      this

    • reflect

      Matrix3f 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 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 Quaternionfc 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:
      this

    • reflect

      Matrix3f reflect(Vector3fc normal, Matrix3f 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

    • isFinite

      boolean isFinite()
      Determine whether all matrix elements are finite floating-point values, that is, they are not NaN and not infinity.
      Returns:
      true if all components are finite floating-point values; false otherwise

    • quadraticFormProduct

      float quadraticFormProduct(float x, float y, float z)
      Compute (x, y, z)^T * this * (x, y, z).
      Parameters:
      x - the x coordinate of the vector to multiply
      y - the y coordinate of the vector to multiply
      z - the z coordinate of the vector to multiply
      Returns:
      the result

    • quadraticFormProduct

      float quadraticFormProduct(Vector3fc v)
      Compute v^T * this * v.
      Parameters:
      v - the vector to multiply
      Returns:
      the result

    • mapXZY

      Matrix3f mapXZY(Matrix3f dest)
      Multiply this by the matrix 
       1 0 0
 0 0 1
 0 1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapXZnY

      Matrix3f mapXZnY(Matrix3f dest)
      Multiply this by the matrix 
       1 0  0
 0 0 -1
 0 1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapXnYnZ

      Matrix3f mapXnYnZ(Matrix3f dest)
      Multiply this by the matrix 
       1  0  0
 0 -1  0
 0  0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapXnZY

      Matrix3f mapXnZY(Matrix3f dest)
      Multiply this by the matrix 
       1  0 0
 0  0 1
 0 -1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapXnZnY

      Matrix3f mapXnZnY(Matrix3f dest)
      Multiply this by the matrix 
       1  0  0
 0  0 -1
 0 -1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYXZ

      Matrix3f mapYXZ(Matrix3f dest)
      Multiply this by the matrix 
       0 1 0
 1 0 0
 0 0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYXnZ

      Matrix3f mapYXnZ(Matrix3f dest)
      Multiply this by the matrix 
       0 1  0
 1 0  0
 0 0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYZX

      Matrix3f mapYZX(Matrix3f dest)
      Multiply this by the matrix 
       0 0 1
 1 0 0
 0 1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYZnX

      Matrix3f mapYZnX(Matrix3f dest)
      Multiply this by the matrix 
       0 0 -1
 1 0  0
 0 1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYnXZ

      Matrix3f mapYnXZ(Matrix3f dest)
      Multiply this by the matrix 
       0 -1 0
 1  0 0
 0  0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYnXnZ

      Matrix3f mapYnXnZ(Matrix3f dest)
      Multiply this by the matrix 
       0 -1  0
 1  0  0
 0  0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYnZX

      Matrix3f mapYnZX(Matrix3f dest)
      Multiply this by the matrix 
       0  0 1
 1  0 0
 0 -1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapYnZnX

      Matrix3f mapYnZnX(Matrix3f dest)
      Multiply this by the matrix 
       0  0 -1
 1  0  0
 0 -1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZXY

      Matrix3f mapZXY(Matrix3f dest)
      Multiply this by the matrix 
       0 1 0
 0 0 1
 1 0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZXnY

      Matrix3f mapZXnY(Matrix3f dest)
      Multiply this by the matrix 
       0 1  0
 0 0 -1
 1 0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZYX

      Matrix3f mapZYX(Matrix3f dest)
      Multiply this by the matrix 
       0 0 1
 0 1 0
 1 0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZYnX

      Matrix3f mapZYnX(Matrix3f dest)
      Multiply this by the matrix 
       0 0 -1
 0 1  0
 1 0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZnXY

      Matrix3f mapZnXY(Matrix3f dest)
      Multiply this by the matrix 
       0 -1 0
 0  0 1
 1  0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZnXnY

      Matrix3f mapZnXnY(Matrix3f dest)
      Multiply this by the matrix 
       0 -1  0
 0  0 -1
 1  0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZnYX

      Matrix3f mapZnYX(Matrix3f dest)
      Multiply this by the matrix 
       0  0 1
 0 -1 0
 1  0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapZnYnX

      Matrix3f mapZnYnX(Matrix3f dest)
      Multiply this by the matrix 
       0  0 -1
 0 -1  0
 1  0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXYnZ

      Matrix3f mapnXYnZ(Matrix3f dest)
      Multiply this by the matrix 
       -1 0  0
  0 1  0
  0 0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXZY

      Matrix3f mapnXZY(Matrix3f dest)
      Multiply this by the matrix 
       -1 0 0
  0 0 1
  0 1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXZnY

      Matrix3f mapnXZnY(Matrix3f dest)
      Multiply this by the matrix 
       -1 0  0
  0 0 -1
  0 1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXnYZ

      Matrix3f mapnXnYZ(Matrix3f dest)
      Multiply this by the matrix 
       -1  0 0
  0 -1 0
  0  0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXnYnZ

      Matrix3f mapnXnYnZ(Matrix3f dest)
      Multiply this by the matrix 
       -1  0  0
  0 -1  0
  0  0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXnZY

      Matrix3f mapnXnZY(Matrix3f dest)
      Multiply this by the matrix 
       -1  0 0
  0  0 1
  0 -1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnXnZnY

      Matrix3f mapnXnZnY(Matrix3f dest)
      Multiply this by the matrix 
       -1  0  0
  0  0 -1
  0 -1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYXZ

      Matrix3f mapnYXZ(Matrix3f dest)
      Multiply this by the matrix 
        0 1 0
 -1 0 0
  0 0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYXnZ

      Matrix3f mapnYXnZ(Matrix3f dest)
      Multiply this by the matrix 
        0 1  0
 -1 0  0
  0 0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYZX

      Matrix3f mapnYZX(Matrix3f dest)
      Multiply this by the matrix 
        0 0 1
 -1 0 0
  0 1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYZnX

      Matrix3f mapnYZnX(Matrix3f dest)
      Multiply this by the matrix 
        0 0 -1
 -1 0  0
  0 1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYnXZ

      Matrix3f mapnYnXZ(Matrix3f dest)
      Multiply this by the matrix 
        0 -1 0
 -1  0 0
  0  0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYnXnZ

      Matrix3f mapnYnXnZ(Matrix3f dest)
      Multiply this by the matrix 
        0 -1  0
 -1  0  0
  0  0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYnZX

      Matrix3f mapnYnZX(Matrix3f dest)
      Multiply this by the matrix 
        0  0 1
 -1  0 0
  0 -1 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnYnZnX

      Matrix3f mapnYnZnX(Matrix3f dest)
      Multiply this by the matrix 
        0  0 -1
 -1  0  0
  0 -1  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZXY

      Matrix3f mapnZXY(Matrix3f dest)
      Multiply this by the matrix 
        0 1 0
  0 0 1
 -1 0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZXnY

      Matrix3f mapnZXnY(Matrix3f dest)
      Multiply this by the matrix 
        0 1  0
  0 0 -1
 -1 0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZYX

      Matrix3f mapnZYX(Matrix3f dest)
      Multiply this by the matrix 
        0 0 1
  0 1 0
 -1 0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZYnX

      Matrix3f mapnZYnX(Matrix3f dest)
      Multiply this by the matrix 
        0 0 -1
  0 1  0
 -1 0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZnXY

      Matrix3f mapnZnXY(Matrix3f dest)
      Multiply this by the matrix 
        0 -1 0
  0  0 1
 -1  0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZnXnY

      Matrix3f mapnZnXnY(Matrix3f dest)
      Multiply this by the matrix 
        0 -1  0
  0  0 -1
 -1  0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZnYX

      Matrix3f mapnZnYX(Matrix3f dest)
      Multiply this by the matrix 
        0  0 1
  0 -1 0
 -1  0 0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • mapnZnYnX

      Matrix3f mapnZnYnX(Matrix3f dest)
      Multiply this by the matrix 
        0  0 -1
  0 -1  0
 -1  0  0
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • negateX

      Matrix3f negateX(Matrix3f dest)
      Multiply this by the matrix 
       -1 0 0
  0 1 0
  0 0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • negateY

      Matrix3f negateY(Matrix3f dest)
      Multiply this by the matrix 
       1  0 0
 0 -1 0
 0  0 1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest

    • negateZ

      Matrix3f negateZ(Matrix3f dest)
      Multiply this by the matrix 
       1 0  0
 0 1  0
 0 0 -1
      and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest