Quaternionf (JOML 1.9.0 API)

java.lang.Object
- org.joml.Quaternionf

All Implemented Interfaces:

Externalizable, Serializable, Quaternionfc
```
public class Quaternionf
extends Object
implements Externalizable, Quaternionfc
```
Contains the definition and functions for rotations expressed as 4-dimensional vectors

Author:

Richard Greenlees, Kai Burjack

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`float`	`w` The real/scalar part of the quaternion.
`float`	`x` The first component of the vector part.
`float`	`y` The second component of the vector part.
`float`	`z` The third component of the vector part.

Constructor Summary

Constructors
Constructor and Description
`Quaternionf()` Create a new `Quaternionf` and initialize it with `(x=0, y=0, z=0, w=1)`, where `(x, y, z)` is the vector part of the quaternion and `w` is the real/scalar part.
`Quaternionf(AxisAngle4f axisAngle)` Create a new `Quaternionf` which represents the rotation of the given `AxisAngle4f`.
`Quaternionf(float x, float y, float z)` Create a new `Quaternionf` and initialize its imaginary components to the given values, and its real part to `1.0`.
`Quaternionf(float x, float y, float z, float w)` Create a new `Quaternionf` and initialize its components to the given values.
`Quaternionf(Quaternionf source)` Create a new `Quaternionf` and initialize its components to the same values as the given `Quaternionf`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Quaternionf`	`add(float x, float y, float z, float w)` Add the quaternion `(x, y, z, w)` to this quaternion.
`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`.
`Quaternionf`	`add(Quaternionfc q2)` Add `q2` to this quaternion.
`Quaternionf`	`add(Quaternionfc q2, Quaternionf dest)` Add `q2` to this quaternion and store the result in `dest`.
`float`	`angle()` Return the angle in radians represented by this quaternion rotation.
`Quaternionf`	`conjugate()` Conjugate this quaternion.
`Quaternionf`	`conjugate(Quaternionf dest)` Conjugate this quaternion and store the result in `dest`.
`Quaternionf`	`difference(Quaternionf other)` Compute the difference between `this` and the `other` quaternion and store the result in `this`.
`Quaternionf`	`difference(Quaternionf other, Quaternionf dest)` Compute the difference between `this` and the `other` quaternion and store the result in `dest`.
`Quaternionf`	`div(Quaternionfc b)` Divide `this` quaternion by `b`.
`Quaternionf`	`div(Quaternionfc b, Quaternionf dest)` Divide `this` quaternion by `b` and store the result in `dest`.
`float`	`dot(Quaternionf otherQuat)` Return the dot of this quaternion and `otherQuat`.
`boolean`	`equals(Object obj)`
`Quaternionf`	`fromAxisAngleDeg(float axisX, float axisY, float axisZ, float angle)` Set this quaternion to be a representation of the supplied axis and angle (in degrees).
`Quaternionf`	`fromAxisAngleDeg(Vector3fc axis, float angle)` Set this quaternion to be a representation of the supplied axis and angle (in degrees).
`Quaternionf`	`fromAxisAngleRad(float axisX, float axisY, float axisZ, float angle)` Set this quaternion to be a representation of the supplied axis and angle (in radians).
`Quaternionf`	`fromAxisAngleRad(Vector3fc axis, float angle)` Set this quaternion to be a representation of the supplied axis and angle (in radians).
`AxisAngle4f`	`get(AxisAngle4f dest)` Set the given `AxisAngle4f` to represent the rotation of `this` quaternion.
`Matrix3d`	`get(Matrix3d dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix3f`	`get(Matrix3f dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix4d`	`get(Matrix4d dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix4f`	`get(Matrix4f dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix4x3d`	`get(Matrix4x3d dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix4x3f`	`get(Matrix4x3f dest)` Set the given destination matrix to the rotation represented by `this`.
`Quaterniond`	`get(Quaterniond dest)` Set the given `Quaterniond` to the values of `this`.
`Quaternionf`	`get(Quaternionf dest)` Set the given `Quaternionf` to the values of `this`.
`ByteBuffer`	`getAsMatrix3f(ByteBuffer dest)` Store the 3x3 float matrix representation of `this` quaternion in column-major order into the given `ByteBuffer`.
`FloatBuffer`	`getAsMatrix3f(FloatBuffer dest)` Store the 3x3 float matrix representation of `this` quaternion in column-major order into the given `FloatBuffer`.
`ByteBuffer`	`getAsMatrix4f(ByteBuffer dest)` Store the 4x4 float matrix representation of `this` quaternion in column-major order into the given `ByteBuffer`.
`FloatBuffer`	`getAsMatrix4f(FloatBuffer dest)` Store the 4x4 float matrix representation of `this` quaternion in column-major order into the given `FloatBuffer`.
`ByteBuffer`	`getAsMatrix4x3f(ByteBuffer dest)` Store the 4x3 float matrix representation of `this` quaternion in column-major order into the given `ByteBuffer`.
`FloatBuffer`	`getAsMatrix4x3f(FloatBuffer dest)` Store the 4x3 float matrix representation of `this` quaternion in column-major order into the given `FloatBuffer`.
`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`.
`int`	`hashCode()`
`Quaternionf`	`identity()` Set this quaternion to the identity.
`Quaternionf`	`integrate(float dt, float vx, float vy, float vz)` 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.
`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`.
`Quaternionf`	`invert()` Invert this quaternion and `normalize` it.
`Quaternionf`	`invert(Quaternionf dest)` Invert this quaternion and store the `normalized` result in `dest`.
`float`	`lengthSquared()` Return the square of the length of this quaternion.
`Quaternionf`	`lookAlong(float dirX, float dirY, float dirZ, float upX, float upY, float upZ)` Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
`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`.
`Quaternionf`	`lookAlong(Vector3fc dir, Vector3fc up)` Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
`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`.
`Quaternionf`	`mul(float qx, float qy, float qz, float qw)` Multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)`.
`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`.
`Quaternionf`	`mul(Quaternionfc q)` Multiply this quaternion by `q`.
`Quaternionf`	`mul(Quaternionfc q, Quaternionf dest)` Multiply this quaternion by `q` and store the result in `dest`.
`static Quaternionfc`	`nlerp(Quaternionfc[] qs, float[] weights, Quaternionf dest)` Interpolate between all of the quaternions given in `qs` via non-spherical linear interpolation using the specified interpolation factors `weights`, and store the result in `dest`.
`Quaternionf`	`nlerp(Quaternionfc q, float factor)` Compute a linear (non-spherical) interpolation of `this` and the given quaternion `q` and store the result in `this`.
`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`.
`static Quaternionfc`	`nlerpIterative(Quaternionf[] qs, float[] weights, float dotThreshold, Quaternionf dest)` Interpolate between all of the quaternions given in `qs` via iterative non-spherical linear interpolation using the specified interpolation factors `weights`, and store the result in `dest`.
`Quaternionf`	`nlerpIterative(Quaternionfc q, float alpha, float dotThreshold)` Compute linear (non-spherical) interpolations of `this` and the given quaternion `q` iteratively and store the result in `this`.
`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`.
`Quaternionf`	`normalize()` Normalize this quaternion.
`Quaternionf`	`normalize(Quaternionf dest)` Normalize this quaternion and store the result in `dest`.
`Vector3f`	`normalizedPositiveX(Vector3f dir)` Obtain the direction of `+X` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3f`	`normalizedPositiveY(Vector3f dir)` Obtain the direction of `+Y` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3f`	`normalizedPositiveZ(Vector3f dir)` Obtain the direction of `+Z` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3f`	`positiveX(Vector3f dir)` Obtain the direction of `+X` before the rotation transformation represented by `this` quaternion is applied.
`Vector3f`	`positiveY(Vector3f dir)` Obtain the direction of `+Y` before the rotation transformation represented by `this` quaternion is applied.
`Vector3f`	`positiveZ(Vector3f dir)` Obtain the direction of `+Z` before the rotation transformation represented by `this` quaternion is applied.
`Quaternionf`	`premul(float qx, float qy, float qz, float qw)` Pre-multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)`.
`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`.
`Quaternionf`	`premul(Quaternionfc q)` Pre-multiply this quaternion by `q`.
`Quaternionf`	`premul(Quaternionfc q, Quaternionf dest)` Pre-multiply this quaternion by `q` and store the result in `dest`.
`void`	`readExternal(ObjectInput in)`
`Quaternionf`	`rotate(float angleX, float angleY, float angleZ)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the cartesian space.
`Quaternionf`	`rotate(float angleX, float angleY, float angleZ, Quaternionf dest)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the cartesian space and store the result in `dest`.
`Quaternionf`	`rotateAxis(float angle, float axisX, float axisY, float axisZ)` Apply a rotation to `this` quaternion rotating the given radians about the specified axis.
`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`.
`Quaternionf`	`rotateAxis(float angle, Vector3fc axis)` Apply a rotation to `this` quaternion rotating the given radians about the specified axis.
`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`.
`Quaternionf`	`rotateLocal(float angleX, float angleY, float angleZ)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion.
`Quaternionf`	`rotateLocal(float angleX, float angleY, float angleZ, Quaternionf dest)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion and store the result in `dest`.
`Quaternionf`	`rotateLocalX(float angle)` Apply a rotation to `this` quaternion rotating the given radians about the local x axis.
`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`.
`Quaternionf`	`rotateLocalY(float angle)` Apply a rotation to `this` quaternion rotating the given radians about the local y axis.
`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`.
`Quaternionf`	`rotateLocalZ(float angle)` Apply a rotation to `this` quaternion rotating the given radians about the local z axis.
`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`.
`Quaternionf`	`rotateTo(float fromDirX, float fromDirY, float fromDirZ, float toDirX, float toDirY, float toDirZ)` Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir`.
`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`.
`Quaternionf`	`rotateTo(Vector3fc fromDir, Vector3fc toDir)` Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir`.
`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`.
`Quaternionf`	`rotateX(float angle)` Apply a rotation to `this` quaternion rotating the given radians about the x axis.
`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`.
`Quaternionf`	`rotateXYZ(float angleX, float angleY, float angleZ)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence `XYZ`.
`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`.
`Quaternionf`	`rotateY(float angle)` Apply a rotation to `this` quaternion rotating the given radians about the y axis.
`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`.
`Quaternionf`	`rotateYXZ(float angleZ, float angleY, float angleX)` 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`.
`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`.
`Quaternionf`	`rotateZ(float angle)` Apply a rotation to `this` quaternion rotating the given radians about the z axis.
`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`.
`Quaternionf`	`rotateZYX(float angleZ, float angleY, float angleX)` 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`.
`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`.
`Quaternionf`	`rotation(float angleX, float angleY, float angleZ)` Set this quaternion to represent a rotation of the given angles in radians about the basis unit axes of the cartesian space.
`Quaternionf`	`rotationAxis(AxisAngle4f axisAngle)` Set this `Quaternionf` to a rotation of the given angle in radians about the supplied axis, all of which are specified via the `AxisAngle4f`.
`Quaternionf`	`rotationAxis(float angle, float axisX, float axisY, float axisZ)` Set this quaternion to a rotation of the given angle in radians about the supplied axis.
`Quaternionf`	`rotationAxis(float angle, Vector3fc axis)` Set this quaternion to a rotation of the given angle in radians about the supplied axis.
`Quaternionf`	`rotationTo(float fromDirX, float fromDirY, float fromDirZ, float toDirX, float toDirY, float toDirZ)` Set `this` quaternion to a rotation that rotates the `fromDir` vector to point along `toDir`.
`Quaternionf`	`rotationTo(Vector3fc fromDir, Vector3fc toDir)` Set `this` quaternion to a rotation that rotates the `fromDir` vector to point along `toDir`.
`Quaternionf`	`rotationX(float angle)` Set this quaternion to represent a rotation of the given radians about the x axis.
`Quaternionf`	`rotationXYZ(float angleX, float angleY, float angleZ)` Set this quaternion from the supplied euler angles (in radians) with rotation order XYZ.
`Quaternionf`	`rotationY(float angle)` Set this quaternion to represent a rotation of the given radians about the y axis.
`Quaternionf`	`rotationYXZ(float angleY, float angleX, float angleZ)` Set this quaternion from the supplied euler angles (in radians) with rotation order YXZ.
`Quaternionf`	`rotationZ(float angle)` Set this quaternion to represent a rotation of the given radians about the z axis.
`Quaternionf`	`rotationZYX(float angleZ, float angleY, float angleX)` Set this quaternion from the supplied euler angles (in radians) with rotation order ZYX.
`Quaternionf`	`scale(float factor)` Scale the rotation represented by this quaternion by the given `factor` using spherical linear interpolation.
`Quaternionf`	`scale(float factor, Quaternionf dest)` Scale the rotation represented by this quaternion by the given `factor` using spherical linear interpolation, and store the result in `dest`.
`Quaternionf`	`set(AxisAngle4d axisAngle)` Set this quaternion to a rotation equivalent to the given `AxisAngle4d`.
`Quaternionf`	`set(AxisAngle4f axisAngle)` Set this quaternion to a rotation equivalent to the given `AxisAngle4f`.
`Quaternionf`	`set(float x, float y, float z)` Set the x, y and z components of this quaternion to the given values.
`Quaternionf`	`set(float x, float y, float z, float w)` Set this quaternion to the given values.
`Quaternionf`	`set(Quaternionfc q)` Set this quaternion to be a copy of q.
`Quaternionf`	`setAngleAxis(double angle, double x, double y, double z)` Set this quaternion to a rotation equivalent to the supplied axis and angle (in radians).
`Quaternionf`	`setAngleAxis(float angle, float x, float y, float z)` Set this quaternion to a rotation equivalent to the supplied axis and angle (in radians).
`Quaternionf`	`setFromNormalized(Matrix3dc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromNormalized(Matrix3fc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromNormalized(Matrix4dc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromNormalized(Matrix4fc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromNormalized(Matrix4x3dc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromNormalized(Matrix4x3fc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromUnnormalized(Matrix3dc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromUnnormalized(Matrix3fc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromUnnormalized(Matrix4dc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromUnnormalized(Matrix4fc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromUnnormalized(Matrix4x3dc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaternionf`	`setFromUnnormalized(Matrix4x3fc mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`static Quaternionfc`	`slerp(Quaternionf[] qs, float[] weights, Quaternionf dest)` Interpolate between all of the quaternions given in `qs` via spherical linear interpolation using the specified interpolation factors `weights`, and store the result in `dest`.
`Quaternionf`	`slerp(Quaternionfc target, float alpha)` Interpolate between `this` quaternion and the specified `target` using spherical linear interpolation using the specified interpolation factor `alpha`.
`Quaternionf`	`slerp(Quaternionfc target, float alpha, Quaternionf dest)` Interpolate between `this` quaternion and the specified `target` using spherical linear interpolation using the specified interpolation factor `alpha`, and store the result in `dest`.
`Quaternionfc`	`toImmutable()` Create a new immutable view of this `Quaternionf`.
`String`	`toString()` Return a string representation of this quaternion.
`String`	`toString(NumberFormat formatter)` Return a string representation of this quaternion by formatting the components with the given `NumberFormat`.
`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`.
`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`.
`Vector3f`	`transform(Vector3f vec)` Transform the given vector by this quaternion.
`Vector3f`	`transform(Vector3fc vec, Vector3f dest)` Transform the given vector by this quaternion and store the result in `dest`.
`Vector4f`	`transform(Vector4f vec)` Transform the given vector by this quaternion.
`Vector4f`	`transform(Vector4fc vec, Vector4f dest)` Transform the given vector by this quaternion and store the result in `dest`.
`float`	`w()`
`void`	`writeExternal(ObjectOutput out)`
`float`	`x()`
`float`	`y()`
`float`	`z()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - x
```
public float x
```
    The first component of the vector part.
  - y
```
public float y
```
    The second component of the vector part.
  - z
```
public float z
```
    The third component of the vector part.
  - w
```
public float w
```
    The real/scalar part of the quaternion.
- Constructor Detail
  - Quaternionf
```
public Quaternionf()
```
    Create a new Quaternionf and initialize it with (x=0, y=0, z=0, w=1), where (x, y, z) is the vector part of the quaternion and w is the real/scalar part.
  - Quaternionf
```
public Quaternionf(float x,
                   float y,
                   float z,
                   float w)
```
    Create a new Quaternionf and initialize its components to the given values.
    
    Parameters:
    
    x - the first component of the imaginary part
    
    y - the second component of the imaginary part
    
    z - the third component of the imaginary part
    
    w - the real part
  - Quaternionf
```
public Quaternionf(float x,
                   float y,
                   float z)
```
    Create a new Quaternionf and initialize its imaginary components to the given values, and its real part to 1.0.
    
    Parameters:
    
    x - the first component of the imaginary part
    
    y - the second component of the imaginary part
    
    z - the third component of the imaginary part
  - Quaternionf
```
public Quaternionf(Quaternionf source)
```
    Create a new Quaternionf and initialize its components to the same values as the given Quaternionf.
    
    Parameters:
    
    source - the Quaternionf to take the component values from
  - Quaternionf
```
public Quaternionf(AxisAngle4f axisAngle)
```
    Create a new Quaternionf which represents the rotation of the given AxisAngle4f.
    
    Parameters:
    
    axisAngle - the AxisAngle4f
- Method Detail
  - x
```
public float x()
```
    Specified by:
    
    x in interface Quaternionfc
    
    Returns:
    
    the first component of the vector part
  - y
```
public float y()
```
    Specified by:
    
    y in interface Quaternionfc
    
    Returns:
    
    the second component of the vector part
  - z
```
public float z()
```
    Specified by:
    
    z in interface Quaternionfc
    
    Returns:
    
    the third component of the vector part
  - w
```
public float w()
```
    Specified by:
    
    w in interface Quaternionfc
    
    Returns:
    
    the real/scalar part of the quaternion
  - normalize
```
public Quaternionf normalize()
```
    Normalize this quaternion.
    
    Returns:
    
    this
  - normalize
```
public Quaternionf normalize(Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Normalize this quaternion and store the result in dest.
    
    Specified by:
    
    normalize in interface Quaternionfc
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - add
```
public Quaternionf add(float x,
                       float y,
                       float z,
                       float w)
```
    Add the quaternion (x, y, z, w) to this quaternion.
    
    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
    
    Returns:
    
    this
  - add
```
public Quaternionf add(float x,
                       float y,
                       float z,
                       float w,
                       Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Add the quaternion (x, y, z, w) to this quaternion and store the result in dest.
    
    Specified by:
    
    add in interface Quaternionfc
    
    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
```
public Quaternionf add(Quaternionfc q2)
```
    Add q2 to this quaternion.
    
    Parameters:
    
    q2 - the quaternion to add to this
    
    Returns:
    
    this
  - add
```
public Quaternionf add(Quaternionfc q2,
                       Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Add q2 to this quaternion and store the result in dest.
    
    Specified by:
    
    add in interface Quaternionfc
    
    Parameters:
    
    q2 - the quaternion to add to this
    
    dest - will hold the result
    
    Returns:
    
    dest
  - dot
```
public float dot(Quaternionf otherQuat)
```
    Return the dot of this quaternion and otherQuat.
    
    Parameters:
    
    otherQuat - the other quaternion
    
    Returns:
    
    the dot product
  - angle
```
public float angle()
```
    Description copied from interface: Quaternionfc
    
    Return the angle in radians represented by this quaternion rotation.
    
    Specified by:
    
    angle in interface Quaternionfc
    
    Returns:
    
    the angle in radians
  - get
```
public Matrix3f get(Matrix3f dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given destination matrix to the rotation represented by this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Matrix3f.set(Quaternionfc)
  - get
```
public Matrix3d get(Matrix3d dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given destination matrix to the rotation represented by this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Matrix3d.set(Quaternionfc)
  - get
```
public Matrix4f get(Matrix4f dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given destination matrix to the rotation represented by this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Matrix4f.set(Quaternionfc)
  - get
```
public Matrix4d get(Matrix4d dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given destination matrix to the rotation represented by this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Matrix4d.set(Quaternionfc)
  - get
```
public Matrix4x3f get(Matrix4x3f dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given destination matrix to the rotation represented by this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Matrix4x3f.set(Quaternionfc)
  - get
```
public Matrix4x3d get(Matrix4x3d dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given destination matrix to the rotation represented by this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Matrix4x3d.set(Quaternionfc)
  - get
```
public AxisAngle4f get(AxisAngle4f dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given AxisAngle4f to represent the rotation of this quaternion.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the AxisAngle4f to set
    
    Returns:
    
    the passed in destination
  - get
```
public Quaterniond get(Quaterniond dest)
```
    Description copied from interface: Quaternionfc
    
    Set the given Quaterniond to the values of this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the Quaterniond to set
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    Quaterniond.set(Quaternionfc)
  - get
```
public Quaternionf get(Quaternionf dest)
```
    Set the given Quaternionf to the values of this.
    
    Specified by:
    
    get in interface Quaternionfc
    
    Parameters:
    
    dest - the Quaternionf to set
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    set(Quaternionfc)
  - getAsMatrix3f
```
public ByteBuffer getAsMatrix3f(ByteBuffer dest)
```
    Description copied from interface: Quaternionfc
    
    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)
    
    Specified by:
    
    getAsMatrix3f in interface Quaternionfc
    
    Parameters:
    
    dest - the destination buffer
    
    Returns:
    
    dest
  - getAsMatrix3f
```
public FloatBuffer getAsMatrix3f(FloatBuffer dest)
```
    Description copied from interface: Quaternionfc
    
    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)
    
    Specified by:
    
    getAsMatrix3f in interface Quaternionfc
    
    Parameters:
    
    dest - the destination buffer
    
    Returns:
    
    dest
  - getAsMatrix4f
```
public ByteBuffer getAsMatrix4f(ByteBuffer dest)
```
    Description copied from interface: Quaternionfc
    
    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)
    
    Specified by:
    
    getAsMatrix4f in interface Quaternionfc
    
    Parameters:
    
    dest - the destination buffer
    
    Returns:
    
    dest
  - getAsMatrix4f
```
public FloatBuffer getAsMatrix4f(FloatBuffer dest)
```
    Description copied from interface: Quaternionfc
    
    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)
    
    Specified by:
    
    getAsMatrix4f in interface Quaternionfc
    
    Parameters:
    
    dest - the destination buffer
    
    Returns:
    
    dest
  - getAsMatrix4x3f
```
public ByteBuffer getAsMatrix4x3f(ByteBuffer dest)
```
    Description copied from interface: Quaternionfc
    
    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)
    
    Specified by:
    
    getAsMatrix4x3f in interface Quaternionfc
    
    Parameters:
    
    dest - the destination buffer
    
    Returns:
    
    dest
  - getAsMatrix4x3f
```
public FloatBuffer getAsMatrix4x3f(FloatBuffer dest)
```
    Description copied from interface: Quaternionfc
    
    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)
    
    Specified by:
    
    getAsMatrix4x3f in interface Quaternionfc
    
    Parameters:
    
    dest - the destination buffer
    
    Returns:
    
    dest
  - set
```
public Quaternionf set(float x,
                       float y,
                       float z,
                       float w)
```
    Set this quaternion to the given values.
    
    Parameters:
    
    x - the new value of x
    
    y - the new value of y
    
    z - the new value of z
    
    w - the new value of w
    
    Returns:
    
    this
  - set
```
public Quaternionf set(float x,
                       float y,
                       float z)
```
    Set the x, y and z components of this quaternion to the given values.
    
    Parameters:
    
    x - the new value of x
    
    y - the new value of y
    
    z - the new value of z
    
    Returns:
    
    this
  - set
```
public Quaternionf set(Quaternionfc q)
```
    Set this quaternion to be a copy of q.
    
    Parameters:
    
    q - the Quaternionf to copy
    
    Returns:
    
    this
  - set
```
public Quaternionf set(AxisAngle4f axisAngle)
```
    Set this quaternion to a rotation equivalent to the given AxisAngle4f.
    
    Parameters:
    
    axisAngle - the AxisAngle4f
    
    Returns:
    
    this
  - set
```
public Quaternionf set(AxisAngle4d axisAngle)
```
    Set this quaternion to a rotation equivalent to the given AxisAngle4d.
    
    Parameters:
    
    axisAngle - the AxisAngle4d
    
    Returns:
    
    this
  - setAngleAxis
```
public Quaternionf setAngleAxis(float angle,
                                float x,
                                float y,
                                float z)
```
    Set this quaternion to a rotation equivalent to the supplied axis and angle (in radians).
    This method assumes that the given rotation axis (x, y, z) is already normalized
    
    Parameters:
    
    angle - the angle in radians
    
    x - the x-component of the normalized rotation axis
    
    y - the y-component of the normalized rotation axis
    
    z - the z-component of the normalized rotation axis
    
    Returns:
    
    this
  - setAngleAxis
```
public Quaternionf setAngleAxis(double angle,
                                double x,
                                double y,
                                double z)
```
    Set this quaternion to a rotation equivalent to the supplied axis and angle (in radians).
    This method assumes that the given rotation axis (x, y, z) is already normalized
    
    Parameters:
    
    angle - the angle in radians
    
    x - the x-component of the normalized rotation axis
    
    y - the y-component of the normalized rotation axis
    
    z - the z-component of the normalized rotation axis
    
    Returns:
    
    this
  - rotationAxis
```
public Quaternionf rotationAxis(AxisAngle4f axisAngle)
```
    Set this Quaternionf to a rotation of the given angle in radians about the supplied axis, all of which are specified via the AxisAngle4f.
    
    Parameters:
    
    axisAngle - the AxisAngle4f giving the rotation angle in radians and the axis to rotate about
    
    Returns:
    
    this
    
    See Also:
    
    rotationAxis(float, float, float, float)
  - rotationAxis
```
public Quaternionf rotationAxis(float angle,
                                float axisX,
                                float axisY,
                                float axisZ)
```
    Set this quaternion to a rotation of the given angle in radians about the supplied axis.
    
    Parameters:
    
    angle - the rotation angle in radians
    
    axisX - the x-coordinate of the rotation axis
    
    axisY - the y-coordinate of the rotation axis
    
    axisZ - the z-coordinate of the rotation axis
    
    Returns:
    
    this
  - rotationAxis
```
public Quaternionf rotationAxis(float angle,
                                Vector3fc axis)
```
    Set this quaternion to a rotation of the given angle in radians about the supplied axis.
    
    Parameters:
    
    angle - the rotation angle in radians
    
    axis - the axis to rotate about
    
    Returns:
    
    this
    
    See Also:
    
    rotationAxis(float, float, float, float)
  - rotation
```
public Quaternionf rotation(float angleX,
                            float angleY,
                            float angleZ)
```
    Set this quaternion to represent a rotation of the given angles in radians about the basis unit axes of the cartesian space.
    
    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
    
    Returns:
    
    this
  - rotationX
```
public Quaternionf rotationX(float angle)
```
    Set this quaternion to represent a rotation of the given radians about the x axis.
    
    Parameters:
    
    angle - the angle in radians to rotate about the x axis
    
    Returns:
    
    this
  - rotationY
```
public Quaternionf rotationY(float angle)
```
    Set this quaternion to represent a rotation of the given radians about the y axis.
    
    Parameters:
    
    angle - the angle in radians to rotate about the y axis
    
    Returns:
    
    this
  - rotationZ
```
public Quaternionf rotationZ(float angle)
```
    Set this quaternion to represent a rotation of the given radians about the z axis.
    
    Parameters:
    
    angle - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaternionf setFromUnnormalized(Matrix4fc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaternionf setFromUnnormalized(Matrix4x3fc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaternionf setFromUnnormalized(Matrix4x3dc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaternionf setFromNormalized(Matrix4fc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaternionf setFromNormalized(Matrix4x3fc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaternionf setFromNormalized(Matrix4x3dc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaternionf setFromUnnormalized(Matrix4dc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaternionf setFromNormalized(Matrix4dc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaternionf setFromUnnormalized(Matrix3fc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaternionf setFromNormalized(Matrix3fc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaternionf setFromUnnormalized(Matrix3dc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaternionf setFromNormalized(Matrix3dc mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - fromAxisAngleRad
```
public Quaternionf fromAxisAngleRad(Vector3fc axis,
                                    float angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in radians).
    
    Parameters:
    
    axis - the rotation axis
    
    angle - the angle in radians
    
    Returns:
    
    this
  - fromAxisAngleRad
```
public Quaternionf fromAxisAngleRad(float axisX,
                                    float axisY,
                                    float axisZ,
                                    float angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in radians).
    
    Parameters:
    
    axisX - the x component of the rotation axis
    
    axisY - the y component of the rotation axis
    
    axisZ - the z component of the rotation axis
    
    angle - the angle in radians
    
    Returns:
    
    this
  - fromAxisAngleDeg
```
public Quaternionf fromAxisAngleDeg(Vector3fc axis,
                                    float angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in degrees).
    
    Parameters:
    
    axis - the rotation axis
    
    angle - the angle in degrees
    
    Returns:
    
    this
  - fromAxisAngleDeg
```
public Quaternionf fromAxisAngleDeg(float axisX,
                                    float axisY,
                                    float axisZ,
                                    float angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in degrees).
    
    Parameters:
    
    axisX - the x component of the rotation axis
    
    axisY - the y component of the rotation axis
    
    axisZ - the z component of the rotation axis
    
    angle - the angle in radians
    
    Returns:
    
    this
  - mul
```
public Quaternionf mul(Quaternionfc q)
```
    Multiply this quaternion by q.
    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
    
    Returns:
    
    this
  - mul
```
public Quaternionf mul(Quaternionfc q,
                       Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    mul in interface Quaternionfc
    
    Parameters:
    
    q - the quaternion to multiply this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - mul
```
public Quaternionf mul(float qx,
                       float qy,
                       float qz,
                       float qw)
```
    Multiply this quaternion by the quaternion represented via (qx, qy, qz, qw).
    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
    
    Returns:
    
    this
  - mul
```
public Quaternionf mul(float qx,
                       float qy,
                       float qz,
                       float qw,
                       Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    mul in interface Quaternionfc
    
    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
```
public Quaternionf premul(Quaternionfc q)
```
    Pre-multiply this quaternion by q.
    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
    
    Returns:
    
    this
  - premul
```
public Quaternionf premul(Quaternionfc q,
                          Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    premul in interface Quaternionfc
    
    Parameters:
    
    q - the quaternion to pre-multiply this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - premul
```
public Quaternionf premul(float qx,
                          float qy,
                          float qz,
                          float qw)
```
    Pre-multiply this quaternion by the quaternion represented via (qx, qy, qz, qw).
    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
    
    Returns:
    
    this
  - premul
```
public Quaternionf premul(float qx,
                          float qy,
                          float qz,
                          float qw,
                          Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    premul in interface Quaternionfc
    
    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
```
public Vector3f transform(Vector3f vec)
```
    Description copied from interface: Quaternionfc
    
    Transform the given vector by this quaternion. This will apply the rotation described by this quaternion to the given vector.
    
    Specified by:
    
    transform in interface Quaternionfc
    
    Parameters:
    
    vec - the vector to transform
    
    Returns:
    
    vec
  - transform
```
public Vector4f transform(Vector4f vec)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    transform in interface Quaternionfc
    
    Parameters:
    
    vec - the vector to transform
    
    Returns:
    
    vec
  - transform
```
public Vector3f transform(Vector3fc vec,
                          Vector3f dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    transform in interface Quaternionfc
    
    Parameters:
    
    vec - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
public Vector3f transform(float x,
                          float y,
                          float z,
                          Vector3f dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    transform in interface Quaternionfc
    
    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
```
public Vector4f transform(Vector4fc vec,
                          Vector4f dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    transform in interface Quaternionfc
    
    Parameters:
    
    vec - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
public Vector4f transform(float x,
                          float y,
                          float z,
                          Vector4f dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    transform in interface Quaternionfc
    
    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
```
public Quaternionf invert(Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Invert this quaternion and store the normalized result in dest.
    If this quaternion is already normalized, then Quaternionfc.conjugate(Quaternionf) should be used instead.
    
    Specified by:
    
    invert in interface Quaternionfc
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    Quaternionfc.conjugate(Quaternionf)
  - invert
```
public Quaternionf invert()
```
    Invert this quaternion and normalize it.
    If this quaternion is already normalized, then conjugate() should be used instead.
    
    Returns:
    
    this
    
    See Also:
    
    conjugate()
  - div
```
public Quaternionf div(Quaternionfc b,
                       Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    div in interface Quaternionfc
    
    Parameters:
    
    b - the Quaternionfc to divide this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - div
```
public Quaternionf div(Quaternionfc b)
```
    Divide this quaternion by b.
    The division expressed using the inverse is performed in the following way:
    this = this * b^-1, where b^-1 is the inverse of b.
    
    Parameters:
    
    b - the Quaternionf to divide this by
    
    Returns:
    
    this
  - conjugate
```
public Quaternionf conjugate()
```
    Conjugate this quaternion.
    
    Returns:
    
    this
  - conjugate
```
public Quaternionf conjugate(Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Conjugate this quaternion and store the result in dest.
    
    Specified by:
    
    conjugate in interface Quaternionfc
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - identity
```
public Quaternionf identity()
```
    Set this quaternion to the identity.
    
    Returns:
    
    this
  - rotateXYZ
```
public Quaternionf rotateXYZ(float angleX,
                             float angleY,
                             float angleZ)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence XYZ.
    This method is equivalent to calling: rotateX(angleX).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
    
    Returns:
    
    this
  - rotateXYZ
```
public Quaternionf rotateXYZ(float angleX,
                             float angleY,
                             float angleZ,
                             Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateXYZ in interface Quaternionfc
    
    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
```
public Quaternionf rotateZYX(float angleZ,
                             float angleY,
                             float angleX)
```
    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.
    This method is equivalent to calling: rotateZ(angleZ).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
    
    Returns:
    
    this
  - rotateZYX
```
public Quaternionf rotateZYX(float angleZ,
                             float angleY,
                             float angleX,
                             Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateZYX in interface Quaternionfc
    
    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
```
public Quaternionf rotateYXZ(float angleZ,
                             float angleY,
                             float angleX)
```
    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.
    This method is equivalent to calling: rotateY(angleY).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
    
    Returns:
    
    this
  - rotateYXZ
```
public Quaternionf rotateYXZ(float angleY,
                             float angleX,
                             float angleZ,
                             Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateYXZ in interface Quaternionfc
    
    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
```
public Vector3f getEulerAnglesXYZ(Vector3f eulerAngles)
```
    Description copied from interface: Quaternionfc
    
    Get the euler angles in radians in rotation sequence XYZ of this quaternion and store them in the provided parameter eulerAngles.
    
    Specified by:
    
    getEulerAnglesXYZ in interface Quaternionfc
    
    Parameters:
    
    eulerAngles - will hold the euler angles in radians
    
    Returns:
    
    the passed in vector
  - lengthSquared
```
public float lengthSquared()
```
    Description copied from interface: Quaternionfc
    
    Return the square of the length of this quaternion.
    
    Specified by:
    
    lengthSquared in interface Quaternionfc
    
    Returns:
    
    the length
  - rotationXYZ
```
public Quaternionf rotationXYZ(float angleX,
                               float angleY,
                               float angleZ)
```
    Set this quaternion from the supplied euler angles (in radians) with rotation order XYZ.
    This method is equivalent to calling: rotationX(angleX).rotateY(angleY).rotateZ(angleZ)
    Reference: this stackexchange answer
    
    Parameters:
    
    angleX - the angle in radians to rotate about x
    
    angleY - the angle in radians to rotate about y
    
    angleZ - the angle in radians to rotate about z
    
    Returns:
    
    this
  - rotationZYX
```
public Quaternionf rotationZYX(float angleZ,
                               float angleY,
                               float angleX)
```
    Set this quaternion from the supplied euler angles (in radians) with rotation order ZYX.
    This method is equivalent to calling: rotationZ(angleZ).rotateY(angleY).rotateX(angleX)
    Reference: this stackexchange answer
    
    Parameters:
    
    angleX - the angle in radians to rotate about x
    
    angleY - the angle in radians to rotate about y
    
    angleZ - the angle in radians to rotate about z
    
    Returns:
    
    this
  - rotationYXZ
```
public Quaternionf rotationYXZ(float angleY,
                               float angleX,
                               float angleZ)
```
    Set this quaternion from the supplied euler angles (in radians) with rotation order YXZ.
    This method is equivalent to calling: rotationY(angleY).rotateX(angleX).rotateZ(angleZ)
    Reference: https://en.wikipedia.org
    
    Parameters:
    
    angleY - the angle in radians to rotate about y
    
    angleX - the angle in radians to rotate about x
    
    angleZ - the angle in radians to rotate about z
    
    Returns:
    
    this
  - slerp
```
public Quaternionf slerp(Quaternionfc target,
                         float alpha)
```
    Interpolate between this quaternion and the specified target using spherical linear interpolation using the specified interpolation factor alpha.
    This method resorts to non-spherical linear interpolation when the absolute dot product of this and target is below 1E-6f.
    
    Parameters:
    
    target - the target of the interpolation, which should be reached with alpha = 1.0
    
    alpha - the interpolation factor, within [0..1]
    
    Returns:
    
    this
  - slerp
```
public Quaternionf slerp(Quaternionfc target,
                         float alpha,
                         Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Interpolate between this quaternion and the specified target 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
    
    Specified by:
    
    slerp in interface Quaternionfc
    
    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
  - slerp
```
public static Quaternionfc slerp(Quaternionf[] qs,
                                 float[] weights,
                                 Quaternionf dest)
```
    Interpolate between all of the quaternions given in qs via spherical linear interpolation using the specified interpolation factors weights, and store the result in dest.
    This method will interpolate between each two successive quaternions via slerp(Quaternionfc, float) using their relative interpolation weights.
    This method resorts to non-spherical linear interpolation when the absolute dot product of any two interpolated quaternions is below 1E-6f.
    Reference: http://gamedev.stackexchange.com/
    
    Parameters:
    
    qs - the quaternions to interpolate over
    
    weights - the weights of each individual quaternion in qs
    
    dest - will hold the result
    
    Returns:
    
    dest
  - scale
```
public Quaternionf scale(float factor)
```
    Scale the rotation represented by this quaternion by the given factor using spherical linear interpolation.
    This method is equivalent to performing a spherical linear interpolation between the unit quaternion and this, and thus equivalent to calling: new Quaternionf().slerp(this, factor)
    Reference: http://fabiensanglard.net
    
    Parameters:
    
    factor - the scaling/interpolation factor, within [0..1]
    
    Returns:
    
    this
    
    See Also:
    
    slerp(Quaternionfc, float)
  - scale
```
public Quaternionf scale(float factor,
                         Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Scale the rotation represented by this quaternion by the given factor using spherical linear interpolation, and store the result in dest.
    This method is equivalent to performing a spherical linear interpolation between the unit quaternion and this, and thus equivalent to calling: new Quaternionf().slerp(this, factor, dest)
    Reference: http://fabiensanglard.net
    
    Specified by:
    
    scale in interface Quaternionfc
    
    Parameters:
    
    factor - the scaling/interpolation factor, within [0..1]
    
    dest - will hold the result
    
    Returns:
    
    this
    
    See Also:
    
    Quaternionfc.slerp(Quaternionfc, float, Quaternionf)
  - integrate
```
public Quaternionf integrate(float dt,
                             float vx,
                             float vy,
                             float vz)
```
    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.
    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)
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotateLocal(float, float, float)
  - integrate
```
public Quaternionf integrate(float dt,
                             float vx,
                             float vy,
                             float vz,
                             Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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/
    
    Specified by:
    
    integrate in interface Quaternionfc
    
    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
    
    See Also:
    
    Quaternionfc.rotateLocal(float, float, float, Quaternionf)
  - nlerp
```
public Quaternionf nlerp(Quaternionfc q,
                         float factor)
```
    Compute a linear (non-spherical) interpolation of this and the given quaternion q and store the result in this.
    
    Parameters:
    
    q - the other quaternion
    
    factor - the interpolation factor. It is between 0.0 and 1.0
    
    Returns:
    
    this
  - nlerp
```
public Quaternionf nlerp(Quaternionfc q,
                         float factor,
                         Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    Compute a linear (non-spherical) interpolation of this and the given quaternion q and store the result in dest.
    Reference: http://fabiensanglard.net
    
    Specified by:
    
    nlerp in interface Quaternionfc
    
    Parameters:
    
    q - the other quaternion
    
    factor - the interpolation factor. It is between 0.0 and 1.0
    
    dest - will hold the result
    
    Returns:
    
    dest
  - nlerp
```
public static Quaternionfc nlerp(Quaternionfc[] qs,
                                 float[] weights,
                                 Quaternionf dest)
```
    Interpolate between all of the quaternions given in qs via non-spherical linear interpolation using the specified interpolation factors weights, and store the result in dest.
    This method will interpolate between each two successive quaternions via nlerp(Quaternionfc, float) using their relative interpolation weights.
    Reference: http://gamedev.stackexchange.com/
    
    Parameters:
    
    qs - the quaternions to interpolate over
    
    weights - the weights of each individual quaternion in qs
    
    dest - will hold the result
    
    Returns:
    
    dest
  - nlerpIterative
```
public Quaternionf nlerpIterative(Quaternionfc q,
                                  float alpha,
                                  float dotThreshold,
                                  Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    nlerpIterative in interface Quaternionfc
    
    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
  - nlerpIterative
```
public Quaternionf nlerpIterative(Quaternionfc q,
                                  float alpha,
                                  float dotThreshold)
```
    Compute linear (non-spherical) interpolations of this and the given quaternion q iteratively and store the result in this.
    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
    
    Returns:
    
    this
  - nlerpIterative
```
public static Quaternionfc nlerpIterative(Quaternionf[] qs,
                                          float[] weights,
                                          float dotThreshold,
                                          Quaternionf dest)
```
    Interpolate between all of the quaternions given in qs via iterative non-spherical linear interpolation using the specified interpolation factors weights, and store the result in dest.
    This method will interpolate between each two successive quaternions via nlerpIterative(Quaternionfc, float, float) using their relative interpolation weights.
    Reference: http://gamedev.stackexchange.com/
    
    Parameters:
    
    qs - the quaternions to interpolate over
    
    weights - the weights of each individual quaternion in qs
    
    dotThreshold - the threshold for the dot product of each two interpolated quaternions above which nlerpIterative(Quaternionfc, float, float) performs another iteration of a small-step linear interpolation
    
    dest - will hold the result
    
    Returns:
    
    dest
  - lookAlong
```
public Quaternionf lookAlong(Vector3fc dir,
                             Vector3fc up)
```
    Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    lookAlong(float, float, float, float, float, float, Quaternionf)
  - lookAlong
```
public Quaternionf lookAlong(Vector3fc dir,
                             Vector3fc up,
                             Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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
    
    Specified by:
    
    lookAlong in interface Quaternionfc
    
    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:
    
    Quaternionfc.lookAlong(float, float, float, float, float, float, Quaternionf)
  - lookAlong
```
public Quaternionf lookAlong(float dirX,
                             float dirY,
                             float dirZ,
                             float upX,
                             float upY,
                             float upZ)
```
    Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    lookAlong(float, float, float, float, float, float, Quaternionf)
  - lookAlong
```
public Quaternionf lookAlong(float dirX,
                             float dirY,
                             float dirZ,
                             float upX,
                             float upY,
                             float upZ,
                             Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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
    
    Specified by:
    
    lookAlong in interface Quaternionfc
    
    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
  - rotationTo
```
public Quaternionf rotationTo(float fromDirX,
                              float fromDirY,
                              float fromDirZ,
                              float toDirX,
                              float toDirY,
                              float toDirZ)
```
    Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
    Since there can be multiple possible rotations, this method chooses the one with the shortest arc.
    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
    
    Returns:
    
    this
  - rotationTo
```
public Quaternionf rotationTo(Vector3fc fromDir,
                              Vector3fc toDir)
```
    Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
    Because there can be multiple possible rotations, this method chooses the one with the shortest arc.
    
    Parameters:
    
    fromDir - the starting direction
    
    toDir - the destination direction
    
    Returns:
    
    this
    
    See Also:
    
    rotationTo(float, float, float, float, float, float)
  - rotateTo
```
public Quaternionf rotateTo(float fromDirX,
                            float fromDirY,
                            float fromDirZ,
                            float toDirX,
                            float toDirY,
                            float toDirZ,
                            Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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
    
    Specified by:
    
    rotateTo in interface Quaternionfc
    
    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
```
public Quaternionf rotateTo(float fromDirX,
                            float fromDirY,
                            float fromDirZ,
                            float toDirX,
                            float toDirY,
                            float toDirZ)
```
    Apply a rotation to this that rotates the fromDir vector to point along toDir.
    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!
    
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotateTo(float, float, float, float, float, float, Quaternionf)
  - rotateTo
```
public Quaternionf rotateTo(Vector3fc fromDir,
                            Vector3fc toDir,
                            Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateTo in interface Quaternionfc
    
    Parameters:
    
    fromDir - the starting direction
    
    toDir - the destination direction
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    Quaternionfc.rotateTo(float, float, float, float, float, float, Quaternionf)
  - rotateTo
```
public Quaternionf rotateTo(Vector3fc fromDir,
                            Vector3fc toDir)
```
    Apply a rotation to this that rotates the fromDir vector to point along toDir.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotateTo(float, float, float, float, float, float, Quaternionf)
  - rotate
```
public Quaternionf rotate(float angleX,
                          float angleY,
                          float angleZ)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the cartesian space.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotate(float, float, float, Quaternionf)
  - rotate
```
public Quaternionf rotate(float angleX,
                          float angleY,
                          float angleZ,
                          Quaternionf dest)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the cartesian space 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!
    
    Specified by:
    
    rotate in interface Quaternionfc
    
    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
    
    See Also:
    
    rotate(float, float, float)
  - rotateLocal
```
public Quaternionf rotateLocal(float angleX,
                               float angleY,
                               float angleZ)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion.
    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:
    
    angleX - the angle in radians to rotate about the local x axis
    
    angleY - the angle in radians to rotate about the local y axis
    
    angleZ - the angle in radians to rotate about the local z axis
    
    Returns:
    
    this
    
    See Also:
    
    rotateLocal(float, float, float, Quaternionf)
  - rotateLocal
```
public Quaternionf rotateLocal(float angleX,
                               float angleY,
                               float angleZ,
                               Quaternionf dest)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion 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!
    
    Specified by:
    
    rotateLocal in interface Quaternionfc
    
    Parameters:
    
    angleX - the angle in radians to rotate about the local x axis
    
    angleY - the angle in radians to rotate about the local y axis
    
    angleZ - the angle in radians to rotate about the local z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateLocal(float, float, float)
  - rotateX
```
public Quaternionf rotateX(float angle)
```
    Apply a rotation to this quaternion rotating the given radians about the x axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotate(float, float, float, Quaternionf)
  - rotateX
```
public Quaternionf rotateX(float angle,
                           Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateX in interface Quaternionfc
    
    Parameters:
    
    angle - the angle in radians to rotate about the x axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    Quaternionfc.rotate(float, float, float, Quaternionf)
  - rotateY
```
public Quaternionf rotateY(float angle)
```
    Apply a rotation to this quaternion rotating the given radians about the y axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotate(float, float, float, Quaternionf)
  - rotateY
```
public Quaternionf rotateY(float angle,
                           Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateY in interface Quaternionfc
    
    Parameters:
    
    angle - the angle in radians to rotate about the y axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    Quaternionfc.rotate(float, float, float, Quaternionf)
  - rotateZ
```
public Quaternionf rotateZ(float angle)
```
    Apply a rotation to this quaternion rotating the given radians about the z axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotate(float, float, float, Quaternionf)
  - rotateZ
```
public Quaternionf rotateZ(float angle,
                           Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateZ in interface Quaternionfc
    
    Parameters:
    
    angle - the angle in radians to rotate about the z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    Quaternionfc.rotate(float, float, float, Quaternionf)
  - rotateLocalX
```
public Quaternionf rotateLocalX(float angle)
```
    Apply a rotation to this quaternion rotating the given radians about the local x axis.
    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
    
    Returns:
    
    this
  - rotateLocalX
```
public Quaternionf rotateLocalX(float angle,
                                Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateLocalX in interface Quaternionfc
    
    Parameters:
    
    angle - the angle in radians to rotate about the local x axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalY
```
public Quaternionf rotateLocalY(float angle)
```
    Apply a rotation to this quaternion rotating the given radians about the local y axis.
    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
    
    Returns:
    
    this
  - rotateLocalY
```
public Quaternionf rotateLocalY(float angle,
                                Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateLocalY in interface Quaternionfc
    
    Parameters:
    
    angle - the angle in radians to rotate about the local y axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalZ
```
public Quaternionf rotateLocalZ(float angle)
```
    Apply a rotation to this quaternion rotating the given radians about the local z axis.
    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
    
    Returns:
    
    this
  - rotateLocalZ
```
public Quaternionf rotateLocalZ(float angle,
                                Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateLocalZ in interface Quaternionfc
    
    Parameters:
    
    angle - the angle in radians to rotate about the local z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateAxis
```
public Quaternionf rotateAxis(float angle,
                              float axisX,
                              float axisY,
                              float axisZ,
                              Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateAxis in interface Quaternionfc
    
    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
```
public Quaternionf rotateAxis(float angle,
                              Vector3fc axis,
                              Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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!
    
    Specified by:
    
    rotateAxis in interface Quaternionfc
    
    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:
    
    Quaternionfc.rotateAxis(float, float, float, float, Quaternionf)
  - rotateAxis
```
public Quaternionf rotateAxis(float angle,
                              Vector3fc axis)
```
    Apply a rotation to this quaternion rotating the given radians about the specified axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotateAxis(float, float, float, float, Quaternionf)
  - rotateAxis
```
public Quaternionf rotateAxis(float angle,
                              float axisX,
                              float axisY,
                              float axisZ)
```
    Apply a rotation to this quaternion rotating the given radians about the specified axis.
    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
    
    Returns:
    
    this
    
    See Also:
    
    rotateAxis(float, float, float, float, Quaternionf)
  - toString
```
public String toString()
```
    Return a string representation of this quaternion.
    This method creates a new DecimalFormat on every invocation with the format string " 0.000E0;-".
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the string representation
  - toString
```
public String toString(NumberFormat formatter)
```
    Return a string representation of this quaternion by formatting the components with the given NumberFormat.
    
    Parameters:
    
    formatter - the NumberFormat used to format the quaternion components with
    
    Returns:
    
    the string representation
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - difference
```
public Quaternionf difference(Quaternionf other)
```
    Compute the difference between this and the other quaternion and store the result in this.
    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
    
    Returns:
    
    this
  - difference
```
public Quaternionf difference(Quaternionf other,
                              Quaternionf dest)
```
    Description copied from interface: Quaternionfc
    
    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.
    
    Specified by:
    
    difference in interface Quaternionfc
    
    Parameters:
    
    other - the other quaternion
    
    dest - will hold the result
    
    Returns:
    
    dest
  - positiveX
```
public Vector3f positiveX(Vector3f dir)
```
    Description copied from interface: Quaternionfc
    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));
 
```
    Specified by:
    
    positiveX in interface Quaternionfc
    
    Parameters:
    
    dir - will hold the direction of +X
    
    Returns:
    
    dir
  - normalizedPositiveX
```
public Vector3f normalizedPositiveX(Vector3f dir)
```
    Description copied from interface: Quaternionfc
    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));
 
```
    Specified by:
    
    normalizedPositiveX in interface Quaternionfc
    
    Parameters:
    
    dir - will hold the direction of +X
    
    Returns:
    
    dir
  - positiveY
```
public Vector3f positiveY(Vector3f dir)
```
    Description copied from interface: Quaternionfc
    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));
 
```
    Specified by:
    
    positiveY in interface Quaternionfc
    
    Parameters:
    
    dir - will hold the direction of +Y
    
    Returns:
    
    dir
  - normalizedPositiveY
```
public Vector3f normalizedPositiveY(Vector3f dir)
```
    Description copied from interface: Quaternionfc
    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));
 
```
    Specified by:
    
    normalizedPositiveY in interface Quaternionfc
    
    Parameters:
    
    dir - will hold the direction of +Y
    
    Returns:
    
    dir
  - positiveZ
```
public Vector3f positiveZ(Vector3f dir)
```
    Description copied from interface: Quaternionfc
    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));
 
```
    Specified by:
    
    positiveZ in interface Quaternionfc
    
    Parameters:
    
    dir - will hold the direction of +Z
    
    Returns:
    
    dir
  - normalizedPositiveZ
```
public Vector3f normalizedPositiveZ(Vector3f dir)
```
    Description copied from interface: Quaternionfc
    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));
 
```
    Specified by:
    
    normalizedPositiveZ in interface Quaternionfc
    
    Parameters:
    
    dir - will hold the direction of +Z
    
    Returns:
    
    dir
  - toImmutable
```
public Quaternionfc toImmutable()
```
    Create a new immutable view of this Quaternionf.
    The observable state of the returned object is the same as that of this, but casting the returned object to Quaternionf will not be possible.
    This method allocates a new instance of a class implementing Quaternionfc on every call.
    
    Returns:
    
    the immutable instance

Class Quaternionf

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

x

y

z

w

Constructor Detail

Quaternionf

Quaternionf

Quaternionf

Quaternionf

Quaternionf

Method Detail

x

y

z

w

normalize

normalize

add

add

add

add

dot

angle

get

get

get

get

get

get

get

get

get

getAsMatrix3f

getAsMatrix3f

getAsMatrix4f

getAsMatrix4f

getAsMatrix4x3f

getAsMatrix4x3f

set

set

set

set

set

setAngleAxis

setAngleAxis

rotationAxis

rotationAxis

rotationAxis

rotation

rotationX

rotationY

rotationZ

setFromUnnormalized

setFromUnnormalized

setFromUnnormalized

setFromNormalized

setFromNormalized

setFromNormalized

setFromUnnormalized

setFromNormalized

setFromUnnormalized

setFromNormalized

setFromUnnormalized

setFromNormalized

fromAxisAngleRad

fromAxisAngleRad

fromAxisAngleDeg

fromAxisAngleDeg

mul

mul

mul

mul

premul

premul