Package org.joml

## Interface Quaterniondc

• All Known Implementing Classes:
`Quaterniond`

`public interface Quaterniondc`
Interface to a read-only view of a quaternion of double-precision floats.
Author:
Kai Burjack
• ### Method Summary

All Methods
Modifier and Type Method Description
`Quaterniond` ```add​(double x, double y, double z, double w, Quaterniond dest)```
Add the quaternion `(x, y, z, w)` to this quaternion and store the result in `dest`.
`Quaterniond` ```add​(Quaterniondc q2, Quaterniond dest)```
Add `q2` to this quaternion and store the result in `dest`.
`double` `angle()`
Return the angle in radians represented by this quaternion rotation.
`Quaterniond` `conjugate​(Quaterniond dest)`
Conjugate this quaternion and store the result in `dest`.
`Quaterniond` ```difference​(Quaterniondc other, Quaterniond dest)```
Compute the difference between `this` and the `other` quaternion and store the result in `dest`.
`Quaterniond` ```div​(Quaterniondc b, Quaterniond dest)```
Divide `this` quaternion by `b` and store the result in `dest`.
`double` `dot​(Quaterniondc otherQuat)`
Return the dot product of this `Quaterniond` and `otherQuat`.
`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`.
`Quaterniond` `get​(Quaterniond dest)`
Set the given `Quaterniond` to the values of `this`.
`Vector3d` `getEulerAnglesXYZ​(Vector3d eulerAngles)`
Get the euler angles in radians in rotation sequence `XYZ` of this quaternion and store them in the provided parameter `eulerAngles`.
`Quaterniond` ```integrate​(double dt, double vx, double vy, double vz, Quaterniond 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`.
`Quaterniond` `invert​(Quaterniond dest)`
Invert this quaternion and store the `normalized` result in `dest`.
`double` `lengthSquared()`
Return the square of the length of this quaternion.
`Quaterniond` ```lookAlong​(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Quaterniond dest)```
Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in `dest`.
`Quaterniond` ```lookAlong​(Vector3dc dir, Vector3dc up, Quaterniond dest)```
Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in `dest`.
`Quaterniond` ```mul​(double qx, double qy, double qz, double qw, Quaterniond dest)```
Multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)` and store the result in `dest`.
`Quaterniond` ```mul​(Quaterniondc q, Quaterniond dest)```
Multiply this quaternion by `q` and store the result in `dest`.
`Quaterniond` ```nlerp​(Quaterniondc q, double factor, Quaterniond dest)```
Compute a linear (non-spherical) interpolation of `this` and the given quaternion `q` and store the result in `dest`.
`Quaterniond` ```nlerpIterative​(Quaterniondc q, double alpha, double dotThreshold, Quaterniond dest)```
Compute linear (non-spherical) interpolations of `this` and the given quaternion `q` iteratively and store the result in `dest`.
`Quaterniond` `normalize​(Quaterniond dest)`
Normalize this quaternion and store the result in `dest`.
`Vector3d` `normalizedPositiveX​(Vector3d dir)`
Obtain the direction of `+X` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d` `normalizedPositiveY​(Vector3d dir)`
Obtain the direction of `+Y` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d` `normalizedPositiveZ​(Vector3d dir)`
Obtain the direction of `+Z` before the rotation transformation represented by `this` normalized quaternion is applied.
`Vector3d` `positiveX​(Vector3d dir)`
Obtain the direction of `+X` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d` `positiveY​(Vector3d dir)`
Obtain the direction of `+Y` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d` `positiveZ​(Vector3d dir)`
Obtain the direction of `+Z` before the rotation transformation represented by `this` quaternion is applied.
`Quaterniond` ```premul​(double qx, double qy, double qz, double qw, Quaterniond dest)```
Pre-multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)` and store the result in `dest`.
`Quaterniond` ```premul​(Quaterniondc q, Quaterniond dest)```
Pre-multiply this quaternion by `q` and store the result in `dest`.
`Quaterniond` ```rotateAxis​(double angle, double axisX, double axisY, double axisZ, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the specified axis and store the result in `dest`.
`Quaterniond` ```rotateAxis​(double angle, Vector3dc axis, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the specified axis and store the result in `dest`.
`Quaterniond` ```rotateLocalX​(double angle, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the local x axis and store the result in `dest`.
`Quaterniond` ```rotateLocalY​(double angle, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the local y axis and store the result in `dest`.
`Quaterniond` ```rotateLocalZ​(double angle, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the local z axis and store the result in `dest`.
`Quaterniond` ```rotateTo​(double fromDirX, double fromDirY, double fromDirZ, double toDirX, double toDirY, double toDirZ, Quaterniond dest)```
Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir` and store the result in `dest`.
`Quaterniond` ```rotateTo​(Vector3dc fromDir, Vector3dc toDir, Quaterniond dest)```
Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir` and store the result in `dest`.
`Quaterniond` ```rotateX​(double angle, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the x axis and store the result in `dest`.
`Quaterniond` ```rotateXYZ​(double angleX, double angleY, double angleZ, Quaterniond 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`.
`Quaterniond` ```rotateY​(double angle, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the y axis and store the result in `dest`.
`Quaterniond` ```rotateYXZ​(double angleY, double angleX, double angleZ, Quaterniond 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`.
`Quaterniond` ```rotateZ​(double angle, Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the z axis and store the result in `dest`.
`Quaterniond` ```rotateZYX​(double angleZ, double angleY, double angleX, Quaterniond 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`.
`Quaterniond` ```scale​(double factor, Quaterniond dest)```
Apply scaling to this quaternion, which results in any vector transformed by the quaternion to change its length by the given `factor`, and store the result in `dest`.
`Quaterniond` ```slerp​(Quaterniondc target, double alpha, Quaterniond dest)```
Interpolate between `this` `unit` quaternion and the specified `target` `unit` quaternion using spherical linear interpolation using the specified interpolation factor `alpha`, and store the result in `dest`.
`Vector3d` ```transform​(double x, double y, double z, Vector3d dest)```
Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector4d` ```transform​(double x, double y, double z, Vector4d dest)```
Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`.
`Vector3d` `transform​(Vector3d vec)`
Transform the given vector by this quaternion.
`Vector3d` ```transform​(Vector3dc vec, Vector3d dest)```
Transform the given vector by this quaternion and store the result in `dest`.
`Vector4d` `transform​(Vector4d vec)`
Transform the given vector by this quaternion.
`Vector4d` ```transform​(Vector4dc vec, Vector4d dest)```
Transform the given vector by this quaternion and store the result in `dest`.
`Vector3d` `transformPositiveX​(Vector3d dest)`
Transform the vector `(1, 0, 0)` by this quaternion.
`Vector4d` `transformPositiveX​(Vector4d dest)`
Transform the vector `(1, 0, 0)` by this quaternion.
`Vector3d` `transformPositiveY​(Vector3d dest)`
Transform the vector `(0, 1, 0)` by this quaternion.
`Vector4d` `transformPositiveY​(Vector4d dest)`
Transform the vector `(0, 1, 0)` by this quaternion.
`Vector3d` `transformPositiveZ​(Vector3d dest)`
Transform the vector `(0, 0, 1)` by this quaternion.
`Vector4d` `transformPositiveZ​(Vector4d dest)`
Transform the vector `(0, 0, 1)` by this quaternion.
`Vector3d` `transformUnitPositiveX​(Vector3d dest)`
Transform the vector `(1, 0, 0)` by this unit quaternion.
`Vector4d` `transformUnitPositiveX​(Vector4d dest)`
Transform the vector `(1, 0, 0)` by this unit quaternion.
`Vector3d` `transformUnitPositiveY​(Vector3d dest)`
Transform the vector `(0, 1, 0)` by this unit quaternion.
`Vector4d` `transformUnitPositiveY​(Vector4d dest)`
Transform the vector `(0, 1, 0)` by this unit quaternion.
`Vector3d` `transformUnitPositiveZ​(Vector3d dest)`
Transform the vector `(0, 0, 1)` by this unit quaternion.
`Vector4d` `transformUnitPositiveZ​(Vector4d dest)`
Transform the vector `(0, 0, 1)` by this unit quaternion.
`double` `w()`
`double` `x()`
`double` `y()`
`double` `z()`
• ### Method Detail

• #### x

`double x()`
Returns:
the first component of the vector part
• #### y

`double y()`
Returns:
the second component of the vector part
• #### z

`double z()`
Returns:
the third component of the vector part
• #### w

`double w()`
Returns:
the real/scalar part of the quaternion
• #### normalize

`Quaterniond normalize​(Quaterniond dest)`
Normalize this quaternion and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest

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

```Quaterniond add​(Quaterniondc q2,
Quaterniond dest)```
Add `q2` to this quaternion and store the result in `dest`.
Parameters:
`q2` - the quaternion to add to this
`dest` - will hold the result
Returns:
dest
• #### dot

`double dot​(Quaterniondc otherQuat)`
Return the dot product of this `Quaterniond` and `otherQuat`.
Parameters:
`otherQuat` - the other quaternion
Returns:
the dot product
• #### angle

`double angle()`
Return the angle in radians represented by this quaternion rotation.
Returns:
• #### get

`Matrix3d get​(Matrix3d dest)`
Set the given destination matrix to the rotation represented by `this`.
Parameters:
`dest` - the matrix to write the rotation into
Returns:
the passed in destination
`Matrix3d.set(Quaterniondc)`
• #### get

`Matrix3f get​(Matrix3f dest)`
Set the given destination matrix to the rotation represented by `this`.
Parameters:
`dest` - the matrix to write the rotation into
Returns:
the passed in destination
`Matrix3f.set(Quaterniondc)`
• #### get

`Matrix4d get​(Matrix4d dest)`
Set the given destination matrix to the rotation represented by `this`.
Parameters:
`dest` - the matrix to write the rotation into
Returns:
the passed in destination
`Matrix4d.set(Quaterniondc)`
• #### get

`Matrix4f get​(Matrix4f dest)`
Set the given destination matrix to the rotation represented by `this`.
Parameters:
`dest` - the matrix to write the rotation into
Returns:
the passed in destination
`Matrix4f.set(Quaterniondc)`
• #### get

`Quaterniond get​(Quaterniond dest)`
Set the given `Quaterniond` to the values of `this`.
Parameters:
`dest` - the `Quaterniond` to set
Returns:
the passed in destination
• #### mul

```Quaterniond mul​(Quaterniondc q,
Quaterniond dest)```
Multiply this quaternion by `q` and store the result in `dest`.

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

`R = T * Q`

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

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

```Quaterniond mul​(double qx,
double qy,
double qz,
double qw,
Quaterniond dest)```
Multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)` and store the result in `dest`.

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

`R = T * Q`

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

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

```Quaterniond premul​(Quaterniondc q,
Quaterniond dest)```
Pre-multiply this quaternion by `q` and store the result in `dest`.

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

`R = Q * T`

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

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

```Quaterniond premul​(double qx,
double qy,
double qz,
double qw,
Quaterniond dest)```
Pre-multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)` and store the result in `dest`.

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

`R = Q * T`

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

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

`Vector3d transform​(Vector3d vec)`
Transform the given vector by this quaternion. This will apply the rotation described by this quaternion to the given vector.
Parameters:
`vec` - the vector to transform
Returns:
vec
• #### transformPositiveX

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`Vector4d transform​(Vector4d vec)`
Transform the given vector by this quaternion. This will apply the rotation described by this quaternion to the given vector.

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

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

```Vector3d transform​(Vector3dc vec,
Vector3d dest)```
Transform the given vector by this quaternion and store the result in `dest`. This will apply the rotation described by this quaternion to the given vector.
Parameters:
`vec` - the vector to transform
`dest` - will hold the result
Returns:
dest
• #### transform

```Vector3d transform​(double x,
double y,
double z,
Vector3d dest)```
Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`. This will apply the rotation described by this quaternion to the given vector.
Parameters:
`x` - the x coordinate of the vector to transform
`y` - the y coordinate of the vector to transform
`z` - the z coordinate of the vector to transform
`dest` - will hold the result
Returns:
dest
• #### transform

```Vector4d transform​(Vector4dc vec,
Vector4d dest)```
Transform the given vector by this quaternion and store the result in `dest`. This will apply the rotation described by this quaternion to the given vector.

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

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

```Vector4d transform​(double x,
double y,
double z,
Vector4d dest)```
Transform the given vector `(x, y, z)` by this quaternion and store the result in `dest`. This will apply the rotation described by this quaternion to the given vector.
Parameters:
`x` - the x coordinate of the vector to transform
`y` - the y coordinate of the vector to transform
`z` - the z coordinate of the vector to transform
`dest` - will hold the result
Returns:
dest
• #### div

```Quaterniond div​(Quaterniondc b,
Quaterniond dest)```
Divide `this` quaternion by `b` and store the result in `dest`.

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

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

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

`Quaterniond conjugate​(Quaterniond dest)`
Conjugate this quaternion and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• #### lengthSquared

`double lengthSquared()`
Return the square of the length of this quaternion.
Returns:
the length
• #### slerp

```Quaterniond slerp​(Quaterniondc target,
double alpha,
Quaterniond dest)```
Interpolate between `this` `unit` quaternion and the specified `target` `unit` quaternion using spherical linear interpolation using the specified interpolation factor `alpha`, and store the result in `dest`.

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

Reference: http://fabiensanglard.net

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

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

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

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

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

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

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

```Quaterniond nlerp​(Quaterniondc q,
double factor,
Quaterniond dest)```
Compute a linear (non-spherical) interpolation of `this` and the given quaternion `q` and store the result in `dest`.

Reference: http://fabiensanglard.net

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

```Quaterniond nlerpIterative​(Quaterniondc q,
double alpha,
double dotThreshold,
Quaterniond dest)```
Compute linear (non-spherical) interpolations of `this` and the given quaternion `q` iteratively and store the result in `dest`.

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

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

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

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

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

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

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
`lookAlong(double, double, double, double, double, double, Quaterniond)`
• #### lookAlong

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

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

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

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
• #### difference

```Quaterniond difference​(Quaterniondc other,
Quaterniond dest)```
Compute the difference between `this` and the `other` quaternion and store the result in `dest`.

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

`T * D = Q`

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

Parameters:
`other` - the other quaternion
`dest` - will hold the result
Returns:
dest
• #### rotateTo

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

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

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

Reference: stackoverflow.com

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

```Quaterniond rotateTo​(Vector3dc fromDir,
Vector3dc toDir,
Quaterniond dest)```
Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir` and store the result in `dest`.

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

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

Parameters:
`fromDir` - the starting direction
`toDir` - the destination direction
`dest` - will hold the result
Returns:
dest
`rotateTo(double, double, double, double, double, double, Quaterniond)`
• #### rotateX

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

```Quaterniond rotateAxis​(double angle,
Vector3dc axis,
Quaterniond dest)```
Apply a rotation to `this` quaternion rotating the given radians about the specified axis and store the result in `dest`.

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

Parameters:
`angle` - the angle in radians to rotate about the specified axis
`axis` - the rotation axis
`dest` - will hold the result
Returns:
dest
`rotateAxis(double, double, double, double, Quaterniond)`
• #### positiveX

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

This method is equivalent to the following code:

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

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

This method is equivalent to the following code:

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

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

This method is equivalent to the following code:

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

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

This method is equivalent to the following code:

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

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

This method is equivalent to the following code:

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

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

This method is equivalent to the following code:

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