Package org.joml

Interface Quaternionfc

All Known Implementing Classes:
Quaternionf

public interface Quaternionfc
Interface to a read-only view of a quaternion of single-precision floats.
Author:
Kai Burjack
  • Method Details

    • x

      float x()
      Returns:
      the first component of the vector part
    • y

      float y()
      Returns:
      the second component of the vector part
    • z

      float z()
      Returns:
      the third component of the vector part
    • w

      float w()
      Returns:
      the real/scalar part of the quaternion
    • normalize

      Quaternionf normalize(Quaternionf dest)
      Normalize this quaternion and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • add

      Quaternionf add(float x, float y, float z, float w, Quaternionf dest)
      Add the quaternion (x, y, z, w) to this quaternion and store the result in dest.
      Parameters:
      x - the x component of the vector part
      y - the y component of the vector part
      z - the z component of the vector part
      w - the real/scalar component
      dest - will hold the result
      Returns:
      dest
    • add

      Add q2 to this quaternion and store the result in dest.
      Parameters:
      q2 - the quaternion to add to this
      dest - will hold the result
      Returns:
      dest
    • angle

      float angle()
      Return the angle in radians represented by this normalized quaternion rotation.

      This quaternion must be normalized.

      Returns:
      the angle in radians
    • get

      Matrix3f get(Matrix3f dest)
      Set the given destination matrix to the rotation represented by this.
      Parameters:
      dest - the matrix to write the rotation into
      Returns:
      the passed in destination
      See Also:
    • get

      Matrix3d get(Matrix3d dest)
      Set the given destination matrix to the rotation represented by this.
      Parameters:
      dest - the matrix to write the rotation into
      Returns:
      the passed in destination
      See Also:
    • get

      Matrix4f get(Matrix4f dest)
      Set the given destination matrix to the rotation represented by this.
      Parameters:
      dest - the matrix to write the rotation into
      Returns:
      the passed in destination
      See Also:
    • get

      Matrix4d get(Matrix4d dest)
      Set the given destination matrix to the rotation represented by this.
      Parameters:
      dest - the matrix to write the rotation into
      Returns:
      the passed in destination
      See Also:
    • get

      Set the given destination matrix to the rotation represented by this.
      Parameters:
      dest - the matrix to write the rotation into
      Returns:
      the passed in destination
      See Also:
    • get

      Set the given destination matrix to the rotation represented by this.
      Parameters:
      dest - the matrix to write the rotation into
      Returns:
      the passed in destination
      See Also:
    • get

      Set the given AxisAngle4f to represent the rotation of this quaternion.
      Parameters:
      dest - the AxisAngle4f to set
      Returns:
      the passed in destination
    • get

      Set the given AxisAngle4d to represent the rotation of this quaternion.
      Parameters:
      dest - the AxisAngle4d to set
      Returns:
      the passed in destination
    • get

      Set the given Quaterniond to the values of this.
      Parameters:
      dest - the Quaterniond to set
      Returns:
      the passed in destination
      See Also:
    • get

      Set the given Quaternionf to the values of this.
      Parameters:
      dest - the Quaternionf to set
      Returns:
      the passed in destination
    • getAsMatrix3f

      ByteBuffer getAsMatrix3f(ByteBuffer dest)
      Store the 3x3 float matrix representation of this quaternion in column-major order into the given ByteBuffer.

      This is equivalent to calling: this.get(new Matrix3f()).get(dest)

      Parameters:
      dest - the destination buffer
      Returns:
      dest
    • getAsMatrix3f

      FloatBuffer getAsMatrix3f(FloatBuffer dest)
      Store the 3x3 float matrix representation of this quaternion in column-major order into the given FloatBuffer.

      This is equivalent to calling: this.get(new Matrix3f()).get(dest)

      Parameters:
      dest - the destination buffer
      Returns:
      dest
    • getAsMatrix4f

      ByteBuffer getAsMatrix4f(ByteBuffer dest)
      Store the 4x4 float matrix representation of this quaternion in column-major order into the given ByteBuffer.

      This is equivalent to calling: this.get(new Matrix4f()).get(dest)

      Parameters:
      dest - the destination buffer
      Returns:
      dest
    • getAsMatrix4f

      FloatBuffer getAsMatrix4f(FloatBuffer dest)
      Store the 4x4 float matrix representation of this quaternion in column-major order into the given FloatBuffer.

      This is equivalent to calling: this.get(new Matrix4f()).get(dest)

      Parameters:
      dest - the destination buffer
      Returns:
      dest
    • getAsMatrix4x3f

      ByteBuffer getAsMatrix4x3f(ByteBuffer dest)
      Store the 4x3 float matrix representation of this quaternion in column-major order into the given ByteBuffer.

      This is equivalent to calling: this.get(new Matrix4x3f()).get(dest)

      Parameters:
      dest - the destination buffer
      Returns:
      dest
    • getAsMatrix4x3f

      FloatBuffer getAsMatrix4x3f(FloatBuffer dest)
      Store the 4x3 float matrix representation of this quaternion in column-major order into the given FloatBuffer.

      This is equivalent to calling: this.get(new Matrix4x3f()).get(dest)

      Parameters:
      dest - the destination buffer
      Returns:
      dest
    • mul

      Multiply this quaternion by q and store the result in dest.

      If T is this and Q is the given quaternion, then the resulting quaternion R is:

      R = T * Q

      So, this method uses post-multiplication like the matrix classes, resulting in a vector to be transformed by Q first, and then by T.

      Parameters:
      q - the quaternion to multiply this by
      dest - will hold the result
      Returns:
      dest
    • mul

      Quaternionf mul(float qx, float qy, float qz, float qw, Quaternionf dest)
      Multiply this quaternion by the quaternion represented via (qx, qy, qz, qw) and store the result in dest.

      If T is this and Q is the given quaternion, then the resulting quaternion R is:

      R = T * Q

      So, this method uses post-multiplication like the matrix classes, resulting in a vector to be transformed by Q first, and then by T.

      Parameters:
      qx - the x component of the quaternion to multiply this by
      qy - the y component of the quaternion to multiply this by
      qz - the z component of the quaternion to multiply this by
      qw - the w component of the quaternion to multiply this by
      dest - will hold the result
      Returns:
      dest
    • premul

      Pre-multiply this quaternion by q and store the result in dest.

      If T is this and Q is the given quaternion, then the resulting quaternion R is:

      R = Q * T

      So, this method uses pre-multiplication, resulting in a vector to be transformed by T first, and then by Q.

      Parameters:
      q - the quaternion to pre-multiply this by
      dest - will hold the result
      Returns:
      dest
    • premul

      Quaternionf premul(float qx, float qy, float qz, float qw, Quaternionf dest)
      Pre-multiply this quaternion by the quaternion represented via (qx, qy, qz, qw) and store the result in dest.

      If T is this and Q is the given quaternion, then the resulting quaternion R is:

      R = Q * T

      So, this method uses pre-multiplication, resulting in a vector to be transformed by T first, and then by Q.

      Parameters:
      qx - the x component of the quaternion to multiply this by
      qy - the y component of the quaternion to multiply this by
      qz - the z component of the quaternion to multiply this by
      qw - the w component of the quaternion to multiply this by
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector3f transform(Vector3f vec)
      Transform the given vector by this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverse

      Vector3f transformInverse(Vector3f vec)
      Transform the given vector by the inverse of this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformUnit

      Vector3f transformUnit(Vector3f vec)
      Transform the given vector by this unit quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformPositiveX

      Vector3f transformPositiveX(Vector3f dest)
      Transform the vector (1, 0, 0) by this quaternion.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveX

      Vector4f transformPositiveX(Vector4f dest)
      Transform the vector (1, 0, 0) by this quaternion.

      Only the first three components of the given 4D vector are modified.

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveX

      Vector3f transformUnitPositiveX(Vector3f dest)
      Transform the vector (1, 0, 0) by this unit quaternion.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveX

      Vector4f transformUnitPositiveX(Vector4f dest)
      Transform the vector (1, 0, 0) by this unit quaternion.

      Only the first three components of the given 4D vector are modified.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveY

      Vector3f transformPositiveY(Vector3f dest)
      Transform the vector (0, 1, 0) by this quaternion.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveY

      Vector4f transformPositiveY(Vector4f dest)
      Transform the vector (0, 1, 0) by this quaternion.

      Only the first three components of the given 4D vector are modified.

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveY

      Vector3f transformUnitPositiveY(Vector3f dest)
      Transform the vector (0, 1, 0) by this unit quaternion.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveY

      Vector4f transformUnitPositiveY(Vector4f dest)
      Transform the vector (0, 1, 0) by this unit quaternion.

      Only the first three components of the given 4D vector are modified.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveZ

      Vector3f transformPositiveZ(Vector3f dest)
      Transform the vector (0, 0, 1) by this quaternion.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveZ

      Vector4f transformPositiveZ(Vector4f dest)
      Transform the vector (0, 0, 1) by this quaternion.

      Only the first three components of the given 4D vector are modified.

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveZ

      Vector3f transformUnitPositiveZ(Vector3f dest)
      Transform the vector (0, 0, 1) by this unit quaternion.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveZ

      Vector4f transformUnitPositiveZ(Vector4f dest)
      Transform the vector (0, 0, 1) by this unit quaternion.

      Only the first three components of the given 4D vector are modified.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector4f transform(Vector4f vec)
      Transform the given vector by this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and modified.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverse

      Vector4f transformInverse(Vector4f vec)
      Transform the given vector by the inverse of this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and modified.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transform

      Vector3f transform(Vector3fc vec, Vector3f dest)
      Transform the given vector by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverse

      Vector3f transformInverse(Vector3fc vec, Vector3f dest)
      Transform the given vector by the inverse of quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector3f transform(float x, float y, float z, Vector3f dest)
      Transform the given vector (x, y, z) by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector3d transform(float x, float y, float z, Vector3d dest)
      Transform the given vector (x, y, z) by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector3f transformInverse(float x, float y, float z, Vector3f dest)
      Transform the given vector (x, y, z) by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector3d transformInverse(float x, float y, float z, Vector3d dest)
      Transform the given vector (x, y, z) by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector3f transformInverseUnit(Vector3f vec)
      Transform the given vector by the inverse of this unit quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformUnit

      Vector3f transformUnit(Vector3fc vec, Vector3f dest)
      Transform the given vector by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverseUnit

      Vector3f transformInverseUnit(Vector3fc vec, Vector3f dest)
      Transform the given vector by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformUnit

      Vector3f transformUnit(float x, float y, float z, Vector3f dest)
      Transform the given vector (x, y, z) by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector3d transformUnit(float x, float y, float z, Vector3d dest)
      Transform the given vector (x, y, z) by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector3f transformInverseUnit(float x, float y, float z, Vector3f dest)
      Transform the given vector (x, y, z) by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector3d transformInverseUnit(float x, float y, float z, Vector3d dest)
      Transform the given vector (x, y, z) by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector4f transform(Vector4fc vec, Vector4f dest)
      Transform the given vector by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverse

      Vector4f transformInverse(Vector4fc vec, Vector4f dest)
      Transform the given vector by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector4f transform(float x, float y, float z, Vector4f dest)
      Transform the given vector (x, y, z) by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector4f transformInverse(float x, float y, float z, Vector4f dest)
      Transform the given vector (x, y, z) by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector4f transformUnit(Vector4fc vec, Vector4f dest)
      Transform the given vector by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformUnit

      Vector4f transformUnit(Vector4f vec)
      Transform the given vector by this unit quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverseUnit

      Vector4f transformInverseUnit(Vector4f vec)
      Transform the given vector by the inverse of this unit quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverseUnit

      Vector4f transformInverseUnit(Vector4fc vec, Vector4f dest)
      Transform the given vector by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformUnit

      Vector4f transformUnit(float x, float y, float z, Vector4f dest)
      Transform the given vector (x, y, z) by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector4f transformInverseUnit(float x, float y, float z, Vector4f dest)
      Transform the given vector (x, y, z) by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector3d transform(Vector3d vec)
      Transform the given vector by this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverse

      Vector3d transformInverse(Vector3d vec)
      Transform the given vector by the inverse of this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformPositiveX

      Vector3d transformPositiveX(Vector3d dest)
      Transform the vector (1, 0, 0) by this quaternion.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveX

      Vector4d transformPositiveX(Vector4d dest)
      Transform the vector (1, 0, 0) by this quaternion.

      Only the first three components of the given 4D vector are modified.

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveX

      Vector3d transformUnitPositiveX(Vector3d dest)
      Transform the vector (1, 0, 0) by this unit quaternion.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveX

      Vector4d transformUnitPositiveX(Vector4d dest)
      Transform the vector (1, 0, 0) by this unit quaternion.

      Only the first three components of the given 4D vector are modified.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveY

      Vector3d transformPositiveY(Vector3d dest)
      Transform the vector (0, 1, 0) by this quaternion.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveY

      Vector4d transformPositiveY(Vector4d dest)
      Transform the vector (0, 1, 0) by this quaternion.

      Only the first three components of the given 4D vector are modified.

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveY

      Vector3d transformUnitPositiveY(Vector3d dest)
      Transform the vector (0, 1, 0) by this unit quaternion.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveY

      Vector4d transformUnitPositiveY(Vector4d dest)
      Transform the vector (0, 1, 0) by this unit quaternion.

      Only the first three components of the given 4D vector are modified.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveZ

      Vector3d transformPositiveZ(Vector3d dest)
      Transform the vector (0, 0, 1) by this quaternion.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformPositiveZ

      Vector4d transformPositiveZ(Vector4d dest)
      Transform the vector (0, 0, 1) by this quaternion.

      Only the first three components of the given 4D vector are modified.

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveZ

      Vector3d transformUnitPositiveZ(Vector3d dest)
      Transform the vector (0, 0, 1) by this unit quaternion.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transformUnitPositiveZ

      Vector4d transformUnitPositiveZ(Vector4d dest)
      Transform the vector (0, 0, 1) by this unit quaternion.

      Only the first three components of the given 4D vector are modified.

      This method is only applicable when this is a unit quaternion.

      Reference: https://de.mathworks.com/

      Parameters:
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector4d transform(Vector4d vec)
      Transform the given vector by this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and modified.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverse

      Vector4d transformInverse(Vector4d vec)
      Transform the given vector by the inverse of this quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and modified.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transform

      Vector3d transform(Vector3dc vec, Vector3d dest)
      Transform the given vector by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverse

      Vector3d transformInverse(Vector3dc vec, Vector3d dest)
      Transform the given vector by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector3d transform(double x, double y, double z, Vector3d dest)
      Transform the given vector (x, y, z) by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector3d transformInverse(double x, double y, double z, Vector3d dest)
      Transform the given vector (x, y, z) by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector4d transform(Vector4dc vec, Vector4d dest)
      Transform the given vector by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverse

      Vector4d transformInverse(Vector4dc vec, Vector4d dest)
      Transform the given vector by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transform

      Vector4d transform(double x, double y, double z, Vector4d dest)
      Transform the given vector (x, y, z) by this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector4d transformInverse(double x, double y, double z, Vector4d dest)
      Transform the given vector (x, y, z) by the inverse of this quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

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

      Vector4d transformUnit(Vector4d vec)
      Transform the given vector by this unit quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and modified.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformInverseUnit

      Vector4d transformInverseUnit(Vector4d vec)
      Transform the given vector by the inverse of this unit quaternion.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and modified.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      Returns:
      vec
    • transformUnit

      Vector3d transformUnit(Vector3dc vec, Vector3d dest)
      Transform the given vector by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverseUnit

      Vector3d transformInverseUnit(Vector3dc vec, Vector3d dest)
      Transform the given vector by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformUnit

      Vector3d transformUnit(double x, double y, double z, Vector3d dest)
      Transform the given vector (x, y, z) by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector3d transformInverseUnit(double x, double y, double z, Vector3d dest)
      Transform the given vector (x, y, z) by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector4d transformUnit(Vector4dc vec, Vector4d dest)
      Transform the given vector by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformInverseUnit

      Vector4d transformInverseUnit(Vector4dc vec, Vector4d dest)
      Transform the given vector by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      Only the first three components of the given 4D vector are being used and set on the destination.

      This method is only applicable when this is a unit quaternion.

      Parameters:
      vec - the vector to transform
      dest - will hold the result
      Returns:
      dest
    • transformUnit

      Vector4d transformUnit(double x, double y, double z, Vector4d dest)
      Transform the given vector (x, y, z) by this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Vector4d transformInverseUnit(double x, double y, double z, Vector4d dest)
      Transform the given vector (x, y, z) by the inverse of this unit quaternion and store the result in dest.

      This will apply the rotation described by this quaternion to the given vector.

      This method is only applicable when this is a unit quaternion.

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

      Quaternionf invert(Quaternionf dest)
      Invert this quaternion and store the normalized result in dest.

      If this quaternion is already normalized, then conjugate(Quaternionf) should be used instead.

      Parameters:
      dest - will hold the result
      Returns:
      dest
      See Also:
    • div

      Divide this quaternion by b and store the result in dest.

      The division expressed using the inverse is performed in the following way:

      dest = this * b^-1, where b^-1 is the inverse of b.

      Parameters:
      b - the Quaternionfc to divide this by
      dest - will hold the result
      Returns:
      dest
    • conjugate

      Quaternionf conjugate(Quaternionf dest)
      Conjugate this quaternion and store the result in dest.
      Parameters:
      dest - will hold the result
      Returns:
      dest
    • rotateXYZ

      Quaternionf rotateXYZ(float angleX, float angleY, float angleZ, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence XYZ and store the result in dest.

      This method is equivalent to calling: rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angleX - the angle in radians to rotate about the x axis
      angleY - the angle in radians to rotate about the y axis
      angleZ - the angle in radians to rotate about the z axis
      dest - will hold the result
      Returns:
      dest
    • rotateZYX

      Quaternionf rotateZYX(float angleZ, float angleY, float angleX, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence ZYX and store the result in dest.

      This method is equivalent to calling: rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angleZ - the angle in radians to rotate about the z axis
      angleY - the angle in radians to rotate about the y axis
      angleX - the angle in radians to rotate about the x axis
      dest - will hold the result
      Returns:
      dest
    • rotateYXZ

      Quaternionf rotateYXZ(float angleY, float angleX, float angleZ, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence YXZ and store the result in dest.

      This method is equivalent to calling: rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angleY - the angle in radians to rotate about the y axis
      angleX - the angle in radians to rotate about the x axis
      angleZ - the angle in radians to rotate about the z axis
      dest - will hold the result
      Returns:
      dest
    • getEulerAnglesXYZ

      Vector3f getEulerAnglesXYZ(Vector3f eulerAngles)
      Get the euler angles in radians in rotation sequence XYZ of this quaternion and store them in the provided parameter eulerAngles.
      Parameters:
      eulerAngles - will hold the euler angles in radians
      Returns:
      the passed in vector
    • lengthSquared

      float lengthSquared()
      Return the square of the length of this quaternion.
      Returns:
      the length
    • slerp

      Quaternionf slerp(Quaternionfc target, float alpha, Quaternionf dest)
      Interpolate between this unit quaternion and the specified target unit quaternion using spherical linear interpolation using the specified interpolation factor alpha, and store the result in dest.

      This method resorts to non-spherical linear interpolation when the absolute dot product of this and target is below 1E-6f.

      Reference: http://fabiensanglard.net

      Parameters:
      target - the target of the interpolation, which should be reached with alpha = 1.0
      alpha - the interpolation factor, within [0..1]
      dest - will hold the result
      Returns:
      dest
    • scale

      Quaternionf scale(float factor, Quaternionf dest)
      Apply scaling to this quaternion, which results in any vector transformed by the quaternion to change its length by the given factor, and store the result in dest.
      Parameters:
      factor - the scaling factor
      dest - will hold the result
      Returns:
      dest
    • integrate

      Quaternionf integrate(float dt, float vx, float vy, float vz, Quaternionf dest)
      Integrate the rotation given by the angular velocity (vx, vy, vz) around the x, y and z axis, respectively, with respect to the given elapsed time delta dt and add the differentiate rotation to the rotation represented by this quaternion and store the result into dest.

      This method pre-multiplies the rotation given by dt and (vx, vy, vz) by this, so the angular velocities are always relative to the local coordinate system of the rotation represented by this quaternion.

      This method is equivalent to calling: rotateLocal(dt * vx, dt * vy, dt * vz, dest)

      Reference: http://physicsforgames.blogspot.de/

      Parameters:
      dt - the delta time
      vx - the angular velocity around the x axis
      vy - the angular velocity around the y axis
      vz - the angular velocity around the z axis
      dest - will hold the result
      Returns:
      dest
    • nlerp

      Quaternionf nlerp(Quaternionfc q, float factor, Quaternionf dest)
      Compute a linear (non-spherical) interpolation of this and the given quaternion q and store the result in dest.

      Reference: http://fabiensanglard.net

      Parameters:
      q - the other quaternion
      factor - the interpolation factor. It is between 0.0 and 1.0
      dest - will hold the result
      Returns:
      dest
    • nlerpIterative

      Quaternionf nlerpIterative(Quaternionfc q, float alpha, float dotThreshold, Quaternionf dest)
      Compute linear (non-spherical) interpolations of this and the given quaternion q iteratively and store the result in dest.

      This method performs a series of small-step nlerp interpolations to avoid doing a costly spherical linear interpolation, like slerp, by subdividing the rotation arc between this and q via non-spherical linear interpolations as long as the absolute dot product of this and q is greater than the given dotThreshold parameter.

      Thanks to @theagentd at http://www.java-gaming.org/ for providing the code.

      Parameters:
      q - the other quaternion
      alpha - the interpolation factor, between 0.0 and 1.0
      dotThreshold - the threshold for the dot product of this and q above which this method performs another iteration of a small-step linear interpolation
      dest - will hold the result
      Returns:
      dest
    • lookAlong

      Quaternionf lookAlong(Vector3fc dir, Vector3fc up, Quaternionf dest)
      Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in dest.

      Because there are multiple possibilities for such a rotation, this method will choose the one that ensures the given up direction to remain parallel to the plane spanned by the up and dir vectors.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Reference: http://answers.unity3d.com

      Parameters:
      dir - the direction to map to the positive Z axis
      up - the vector which will be mapped to a vector parallel to the plane spanned by the given dir and up
      dest - will hold the result
      Returns:
      dest
      See Also:
    • lookAlong

      Quaternionf lookAlong(float dirX, float dirY, float dirZ, float upX, float upY, float upZ, Quaternionf dest)
      Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in dest.

      Because there are multiple possibilities for such a rotation, this method will choose the one that ensures the given up direction to remain parallel to the plane spanned by the up and dir vectors.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Reference: http://answers.unity3d.com

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

      Quaternionf rotateTo(float fromDirX, float fromDirY, float fromDirZ, float toDirX, float toDirY, float toDirZ, Quaternionf dest)
      Apply a rotation to this that rotates the fromDir vector to point along toDir and store the result in dest.

      Since there can be multiple possible rotations, this method chooses the one with the shortest arc.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Reference: stackoverflow.com

      Parameters:
      fromDirX - the x-coordinate of the direction to rotate into the destination direction
      fromDirY - the y-coordinate of the direction to rotate into the destination direction
      fromDirZ - the z-coordinate of the direction to rotate into the destination direction
      toDirX - the x-coordinate of the direction to rotate to
      toDirY - the y-coordinate of the direction to rotate to
      toDirZ - the z-coordinate of the direction to rotate to
      dest - will hold the result
      Returns:
      dest
    • rotateTo

      Quaternionf rotateTo(Vector3fc fromDir, Vector3fc toDir, Quaternionf dest)
      Apply a rotation to this that rotates the fromDir vector to point along toDir and store the result in dest.

      Because there can be multiple possible rotations, this method chooses the one with the shortest arc.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      fromDir - the starting direction
      toDir - the destination direction
      dest - will hold the result
      Returns:
      dest
      See Also:
    • rotateX

      Quaternionf rotateX(float angle, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the x axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the x axis
      dest - will hold the result
      Returns:
      dest
    • rotateY

      Quaternionf rotateY(float angle, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the y axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the y axis
      dest - will hold the result
      Returns:
      dest
    • rotateZ

      Quaternionf rotateZ(float angle, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the z axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the z axis
      dest - will hold the result
      Returns:
      dest
    • rotateLocalX

      Quaternionf rotateLocalX(float angle, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the local x axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the local x axis
      dest - will hold the result
      Returns:
      dest
    • rotateLocalY

      Quaternionf rotateLocalY(float angle, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the local y axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the local y axis
      dest - will hold the result
      Returns:
      dest
    • rotateLocalZ

      Quaternionf rotateLocalZ(float angle, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the local z axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the local z axis
      dest - will hold the result
      Returns:
      dest
    • rotateAxis

      Quaternionf rotateAxis(float angle, float axisX, float axisY, float axisZ, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the specified axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the specified axis
      axisX - the x coordinate of the rotation axis
      axisY - the y coordinate of the rotation axis
      axisZ - the z coordinate of the rotation axis
      dest - will hold the result
      Returns:
      dest
    • rotateAxis

      Quaternionf rotateAxis(float angle, Vector3fc axis, Quaternionf dest)
      Apply a rotation to this quaternion rotating the given radians about the specified axis and store the result in dest.

      If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!

      Parameters:
      angle - the angle in radians to rotate about the specified axis
      axis - the rotation axis
      dest - will hold the result
      Returns:
      dest
      See Also:
    • difference

      Quaternionf difference(Quaternionfc other, Quaternionf dest)
      Compute the difference between this and the other quaternion and store the result in dest.

      The difference is the rotation that has to be applied to get from this rotation to other. If T is this, Q is other and D is the computed difference, then the following equation holds:

      T * D = Q

      It is defined as: D = T^-1 * Q, where T^-1 denotes the inverse of T.

      Parameters:
      other - the other quaternion
      dest - will hold the result
      Returns:
      dest
    • positiveX

      Vector3f positiveX(Vector3f dir)
      Obtain the direction of +X before the rotation transformation represented by this quaternion is applied.

      This method is equivalent to the following code:

       Quaternionf inv = new Quaternionf(this).invert();
       inv.transform(dir.set(1, 0, 0));
       
      Parameters:
      dir - will hold the direction of +X
      Returns:
      dir
    • normalizedPositiveX

      Vector3f normalizedPositiveX(Vector3f dir)
      Obtain the direction of +X before the rotation transformation represented by this normalized quaternion is applied. The quaternion must be normalized for this method to work.

      This method is equivalent to the following code:

       Quaternionf inv = new Quaternionf(this).conjugate();
       inv.transform(dir.set(1, 0, 0));
       
      Parameters:
      dir - will hold the direction of +X
      Returns:
      dir
    • positiveY

      Vector3f positiveY(Vector3f dir)
      Obtain the direction of +Y before the rotation transformation represented by this quaternion is applied.

      This method is equivalent to the following code:

       Quaternionf inv = new Quaternionf(this).invert();
       inv.transform(dir.set(0, 1, 0));
       
      Parameters:
      dir - will hold the direction of +Y
      Returns:
      dir
    • normalizedPositiveY

      Vector3f normalizedPositiveY(Vector3f dir)
      Obtain the direction of +Y before the rotation transformation represented by this normalized quaternion is applied. The quaternion must be normalized for this method to work.

      This method is equivalent to the following code:

       Quaternionf inv = new Quaternionf(this).conjugate();
       inv.transform(dir.set(0, 1, 0));
       
      Parameters:
      dir - will hold the direction of +Y
      Returns:
      dir
    • positiveZ

      Vector3f positiveZ(Vector3f dir)
      Obtain the direction of +Z before the rotation transformation represented by this quaternion is applied.

      This method is equivalent to the following code:

       Quaternionf inv = new Quaternionf(this).invert();
       inv.transform(dir.set(0, 0, 1));
       
      Parameters:
      dir - will hold the direction of +Z
      Returns:
      dir
    • normalizedPositiveZ

      Vector3f normalizedPositiveZ(Vector3f dir)
      Obtain the direction of +Z before the rotation transformation represented by this normalized quaternion is applied. The quaternion must be normalized for this method to work.

      This method is equivalent to the following code:

       Quaternionf inv = new Quaternionf(this).conjugate();
       inv.transform(dir.set(0, 0, 1));
       
      Parameters:
      dir - will hold the direction of +Z
      Returns:
      dir
    • conjugateBy

      Quaternionf conjugateBy(Quaternionfc q, Quaternionf dest)
      Conjugate this by the given quaternion q by computing q * this * q^-1 and store the result into dest.
      Parameters:
      q - the Quaternionfc to conjugate this by
      dest - will hold the result
      Returns:
      dest
    • isFinite

      boolean isFinite()
      Determine whether all components 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
    • equals

      boolean equals(Quaternionfc q, float delta)
      Compare the quaternion components of this quaternion with the given quaternion 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:
      q - the other quaternion
      delta - the allowed maximum difference
      Returns:
      true whether all of the quaternion components are equal; false otherwise
    • equals

      boolean equals(float x, float y, float z, float w)
      Parameters:
      x - the x component to compare to
      y - the y component to compare to
      z - the z component to compare to
      w - the w component to compare to
      Returns:
      true if all the quaternion components are equal