Quat (Bonzai Engine bonzaiengine.com Copyright © 2007-2019 Jérôme Jouvie)

java.lang.Object
- com.bonzaiengine.math.Quat

All Implemented Interfaces:

IInterpolable<Quat>, IData<Quat>, IValueCopy<Quat>, java.lang.Cloneable
```
public final class Quat
extends java.lang.Object
implements IData<Quat>
```
A quaternion representation, backed with 4 floats.

Field Summary

Fields
Modifier and Type Field and Description

static Quat IDENTITY

protected float w

protected float x

protected float y

protected float z

Fields
Modifier and Type	Field and Description
`static Quat`	`IDENTITY`
`protected float`	`w`
`protected float`	`x`
`protected float`	`y`
`protected float`	`z`

Constructor Summary

Constructors
Constructor and Description

Quat()

Quat(float x, float y, float z, float w)

Constructors
Constructor and Description
`Quat()`
`Quat(float x, float y, float z, float w)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Quat`	`clone()`
`Quat`	`conjugate()` Conjugate (negate) this quaternion.
`float`	`distance(Quat q)`
`Quat`	`divide(Quat q1, Quat q2)` Divide q1 by q2, and store the result in this quaternion.
`boolean`	`equals(java.lang.Object obj)`
`float`	`getAngleProjected(Vec3 refAxis)`
`Vec3`	`getAnglesXYZ(Vec3 dst)` Convert this quaternion into angles ordered: x, y, z Reference: http://jeux.developpez.com/faq/matquat/?
`Vec3`	`getAnglesYX(Vec3 dst)` Convert this quaternion into angles ordered: y, x
`Vec3`	`getAnglesZYX(Vec3 dst)` Convert this quaternion into angles ordered: z, y, x Reference: http://jeux.developpez.com/faq/matquat/?
`float`	`getAxisAngle(Vec3 dstAxis)`
`Vec3`	`getAxisX(Vec3 dst)` Get the axis x or the left vector defining by this quaternion
`Vec3`	`getAxisY(Vec3 dst)` Get the axis y or the up vector defining by this quaternion
`Vec3`	`getAxisZ(Vec3 dst)` Forward vector
`protected Vec3`	`getLookAtForward(Vec3 dst)`
`protected Vec3`	`getLookAtLeft(Vec3 dst)`
`protected void`	`getLookAtMatrix(Mat4x4 matrix)`
`protected Vec3`	`getLookAtUp(Vec3 dst)`
`Mat4x4`	`getMatrix(Mat4x4 matrix)` Create a 4x4 rotation matrix
`void`	`getMatrix3x3(Mat4x4 matrix)`
`void`	`getTwistDecomposition(Quat rot, Quat twist, Vec3 axis)` Decompose the quaternion in a rotation quaternion `rot` (perpendicular to the axis) and a twist rotation `twist` (along the axis) such as: this == new Quat().multiply(rot, twist)
`float`	`getW()`
`float`	`getX()`
`float`	`getY()`
`float`	`getZ()`
`int`	`hashCode()`
`Quat`	`interpolate(Quat current, Quat next, float t)` Equivalent to slerp
`Quat`	`invert()` Invert this quaternion.
`boolean`	`isIdentity()`
`float`	`length()`
`float`	`lengthSqr()`
`protected static void`	`multiply(Mat4x4 dst, Mat4x4 src, Quat q)`
`Quat`	`multiply(Quat q1, Quat q2)` Multiply q1 by q2, and store the result in this quaternion.
`float`	`normalize()` Normalize this quaternion
`Vec3`	`rotate(Vec3 dst, Vec3 src)` This is equivalent to transform a vector by the equivalent matrix.
`Vec3`	`rotateTransposed(Vec3 dst, Vec3 src)` This is equivalent to rotateTransposed a vector by the equivalent matrix.
`Quat`	`scale(float scale)` Scale this quaternion.
`Quat`	`set(float x, float y, float z, float w)`
`Quat`	`set(Quat src)`
`Quat`	`setAnglesXYZ(float angleXInRadians, float angleYInRadians, float angleZInRadians)` Create a quaternion from angles, as defined by the order: x, y, z This method is strictly equivalent than: final Quaternion4f q_ = new Quaternion4f(); this.setAxisAngle(Vector3f.axisX, angleXInRadians); this.multiply(q_.setAxisAngle(Vector3f.axisY, angleYInRadians)); this.multiply(q_.setAxisAngle(Vector3f.axisZ, angleZInRadians)); This code has been inlined and optimized.
`Quat`	`setAnglesZYX(float angleXInRadians, float angleYInRadians, float angleZInRadians)` Create a quaternion from angles, as defined by the order: z, y, x This method is strictly equivalent than: final Quaternion4f q_ = new Quaternion4f(); this.setAxisAngle(Vector3f.axisZ, angleZInRadians); this.multiply(q_.setAxisAngle(Vector3f.axisY, angleYInRadians)); this.multiply(q_.setAxisAngle(Vector3f.axisX, angleYInRadians)); This code has been inlined and optimized.
`Quat`	`setAxis(Vec3 axisX, Vec3 axisY, Vec3 axisZ)` Deprecated.
`Quat`	`setAxisAngle(Vec3 axis, float angleInRadians)` Create a quaternion from an axis angle rotation representation.
`Quat`	`setIdentity()` Set this quaternion as the identity quaternion (0, 0, 0, 1).
`protected Quat`	`setLookAtMatrix(Mat4x4 m)`
`Quat`	`setRotationMatrix(Mat4x4 m)` Warning: This is only valid for normalized matrix, right handed with no scaling.
`Quat`	`setVectorRotation(Vec3 vec1, Vec3 vec2)` Shortest arc rotation between the two specified vectors
`Quat`	`slerp(Quat current, Quat next, float t)` Spherical linear interpolation
`java.lang.String`	`toString()`

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

- Field Detail
  - IDENTITY
```
public static final Quat IDENTITY
```
  - x
```
protected float x
```
  - y
```
protected float y
```
  - z
```
protected float z
```
  - w
```
protected float w
```
- Constructor Detail
  - Quat
```
public Quat()
```
  - Quat
```
public Quat(float x,
            float y,
            float z,
            float w)
```
- Method Detail
  - clone
```
public final Quat clone()
```
    Specified by:
    
    clone in interface IData<Quat>
    
    Specified by:
    
    clone in interface IValueCopy<Quat>
    
    Overrides:
    
    clone in class java.lang.Object
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public final boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - toString
```
public final java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - set
```
public final Quat set(Quat src)
```
    Specified by:
    
    set in interface IValueCopy<Quat>
    
    Parameters:
    
    src - source quaternion to copy to this
    
    Returns:
    
    this
  - set
```
public final Quat set(float x,
                      float y,
                      float z,
                      float w)
```
    Parameters:
    
    x -
    
    y -
    
    z -
    
    w -
    
    Returns:
    
    this
  - setIdentity
```
public final Quat setIdentity()
```
    Set this quaternion as the identity quaternion (0, 0, 0, 1).
    An identity quaternion is equivalent to an identity matrix.
    
    Returns:
    
    this
  - isIdentity
```
public final boolean isIdentity()
```
    Returns:
    
    true if this quaternion is the identity quaternion (0, 0, 0, 1)
  - distance
```
public final float distance(Quat q)
```
    Returns:
    
    the distance considering the matrix as a 4 length vector
  - setAnglesXYZ
```
public final Quat setAnglesXYZ(float angleXInRadians,
                               float angleYInRadians,
                               float angleZInRadians)
```
    Create a quaternion from angles, as defined by the order: x, y, z
    
    This method is strictly equivalent than:
```
  final Quaternion4f q_ = new Quaternion4f();
  this.setAxisAngle(Vector3f.axisX, angleXInRadians);
  this.multiply(q_.setAxisAngle(Vector3f.axisY, angleYInRadians));
  this.multiply(q_.setAxisAngle(Vector3f.axisZ, angleZInRadians));
  
```
    This code has been inlined and optimized.
    Parameters:
    
    angleXInRadians - rotation around x, in radians
    
    angleYInRadians - rotation around y, in radians
    
    angleZInRadians - rotation around z, in radians
    
    Returns:
    
    this
  - setAnglesZYX
```
public final Quat setAnglesZYX(float angleXInRadians,
                               float angleYInRadians,
                               float angleZInRadians)
```
    Create a quaternion from angles, as defined by the order: z, y, x
    
    This method is strictly equivalent than:
```
  final Quaternion4f q_ = new Quaternion4f();
  this.setAxisAngle(Vector3f.axisZ, angleZInRadians);
  this.multiply(q_.setAxisAngle(Vector3f.axisY, angleYInRadians));
  this.multiply(q_.setAxisAngle(Vector3f.axisX, angleYInRadians));
  
```
    This code has been inlined and optimized.
    Parameters:
    
    angleXInRadians - rotation around x, in radians
    
    angleYInRadians - rotation around y, in radians
    
    angleZInRadians - rotation around z, in radians
    
    Returns:
    
    this
  - setAxisAngle
```
public final Quat setAxisAngle(Vec3 axis,
                               float angleInRadians)
```
    Create a quaternion from an axis angle rotation representation.
    
    Parameters:
    
    axis - rotation axis
    
    angleInRadians - rotation angle in radians
    
    Returns:
    
    this
  - setVectorRotation
```
public final Quat setVectorRotation(Vec3 vec1,
                                    Vec3 vec2)
```
    Shortest arc rotation between the two specified vectors
    
    Parameters:
    
    vec1 -
    
    vec2 -
    
    Returns:
    
    this
  - setRotationMatrix
```
public final Quat setRotationMatrix(Mat4x4 m)
```
    Warning: This is only valid for normalized matrix, right handed with no scaling.
    It is recommended to use a safer matrix to quaternion conversion, as available in Matrix16f#getRotationAndScale(Quaternion4f, Vector3f) and Transform#setMatrix(Matrix16f).
    
    Parameters:
    
    m - a rotation matrix that comply to application conditions
    
    Returns:
    
    this
    
    See Also:
    
    Mat4x4.getRotationAndScale(Quat, Vec3), Transform
  - setAxis
```
@Deprecated
public final Quat setAxis(Vec3 axisX,
                                      Vec3 axisY,
                                      Vec3 axisZ)
```
    Deprecated.
  - setLookAtMatrix
```
protected final Quat setLookAtMatrix(Mat4x4 m)
```
  - multiply
```
protected static final void multiply(Mat4x4 dst,
                                     Mat4x4 src,
                                     Quat q)
```
  - getMatrix
```
public final Mat4x4 getMatrix(Mat4x4 matrix)
```
    Create a 4x4 rotation matrix
    
    Returns:
    
    matrix
  - getMatrix3x3
```
public final void getMatrix3x3(Mat4x4 matrix)
```
  - getLookAtMatrix
```
protected final void getLookAtMatrix(Mat4x4 matrix)
```
  - getAnglesXYZ
```
public final Vec3 getAnglesXYZ(Vec3 dst)
```
    Convert this quaternion into angles ordered: x, y, z
    
    Reference: http://jeux.developpez.com/faq/matquat/?page=transformations#Q37
    
    Parameters:
    
    dst - destination vector to store the angles in radians (angleX, angleY, angleZ)
  - getAnglesZYX
```
public final Vec3 getAnglesZYX(Vec3 dst)
```
    Convert this quaternion into angles ordered: z, y, x
    
    Reference: http://jeux.developpez.com/faq/matquat/?page=transformations#Q37
    
    Parameters:
    
    dst - destination vector to store the angles in radians (angleX, angleY, angleZ)
  - getAnglesYX
```
public final Vec3 getAnglesYX(Vec3 dst)
```
    Convert this quaternion into angles ordered: y, x
    
    Parameters:
    
    dst - destination vector to store the angles in radians (angleX, angleY, 0)
  - getAxisAngle
```
public final float getAxisAngle(Vec3 dstAxis)
```
    Parameters:
    
    dstAxis - destination vector to store the Axis (x,y,z)
    
    Returns:
    
    angle
  - getAngleProjected
```
public final float getAngleProjected(Vec3 refAxis)
```
  - getTwistDecomposition
```
public final void getTwistDecomposition(Quat rot,
                                        Quat twist,
                                        Vec3 axis)
```
    Decompose the quaternion in a rotation quaternion rot (perpendicular to the axis) and a twist rotation twist (along the axis) such as:
```
this == new Quat().multiply(rot, twist)
```
    Parameters:
    
    rot - destination Quat to store the perpendicular rotation
    
    twist - destination Quat to store the twist rotation around the specified axis
    
    axis - twist axis
  - interpolate
```
public final Quat interpolate(Quat current,
                              Quat next,
                              float t)
```
    Equivalent to slerp
    
    Specified by:
    
    interpolate in interface IInterpolable<Quat>
    
    Specified by:
    
    interpolate in interface IData<Quat>
    
    Parameters:
    
    current - current value
    
    next - next value
    
    t - interpolation percent in range [0;1]
    
    Returns:
    
    this
    
    See Also:
    
    slerp(Quat, Quat, float)
  - slerp
```
public final Quat slerp(Quat current,
                        Quat next,
                        float t)
```
    Spherical linear interpolation
    
    Parameters:
    
    current - first quaternion
    
    next - second quaternion
    
    t - percentage in range [0f;1f]
    
    Returns:
    
    this quaternion containing the slerp of the two quaternion
  - multiply
```
public final Quat multiply(Quat q1,
                           Quat q2)
```
    Multiply q1 by q2, and store the result in this quaternion.
    
    Parameters:
    
    q1 - first quaternion
    
    q2 - second quaternion
    
    Returns:
    
    this
  - divide
```
public final Quat divide(Quat q1,
                         Quat q2)
```
    Divide q1 by q2, and store the result in this quaternion.
    This is equivalent to multiply q1 by the inverse of q2.
    
    Parameters:
    
    q1 - first quaternion
    
    q2 - second quaternion
    
    Returns:
    
    this
  - rotate
```
public final Vec3 rotate(Vec3 dst,
                         Vec3 src)
```
    This is equivalent to transform a vector by the equivalent matrix.
    
    Parameters:
    
    dst - the destination vector to store the rotated vector
    
    src - source vector to rotate
    
    Returns:
    
    dst
  - rotateTransposed
```
public final Vec3 rotateTransposed(Vec3 dst,
                                   Vec3 src)
```
    This is equivalent to rotateTransposed a vector by the equivalent matrix.
    
    Parameters:
    
    dst - the destination vector to store the rotated vector
    
    src - source vector to rotate
    
    Returns:
    
    dst
  - length
```
public final float length()
```
    Returns:
    
    the length of this quaternion
  - lengthSqr
```
public final float lengthSqr()
```
    Returns:
    
    the length squared of this quaternion
  - invert
```
public final Quat invert()
```
    Invert this quaternion.
    This is equivalent to conjugate and scale by 1 / (length * length)
    
    Returns:
    
    this
  - normalize
```
public final float normalize()
```
    Normalize this quaternion
    
    Returns:
    
    this
  - conjugate
```
public final Quat conjugate()
```
    Conjugate (negate) this quaternion.
    This is equivalent to transpose the corresponding matrix.
    
    Returns:
    
    this
  - scale
```
public final Quat scale(float scale)
```
    Scale this quaternion.
    
    Returns:
    
    this
  - getAxisX
```
public final Vec3 getAxisX(Vec3 dst)
```
    Get the axis x or the left vector defining by this quaternion
    
    Parameters:
    
    dst - destination vector to store the axis x
    
    Returns:
    
    dst
  - getAxisY
```
public final Vec3 getAxisY(Vec3 dst)
```
    Get the axis y or the up vector defining by this quaternion
    
    Parameters:
    
    dst - destination vector to store the axis x
    
    Returns:
    
    dst
  - getAxisZ
```
public final Vec3 getAxisZ(Vec3 dst)
```
    Forward vector
  - getLookAtLeft
```
protected final Vec3 getLookAtLeft(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the left vector of the look at matrix
    
    Returns:
    
    dst
    
    See Also:
    
    getLookAtMatrix(Mat4x4)
  - getLookAtUp
```
protected final Vec3 getLookAtUp(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the up vector of the look at matrix
    
    Returns:
    
    dst
    
    See Also:
    
    getLookAtMatrix(Mat4x4)
  - getLookAtForward
```
protected final Vec3 getLookAtForward(Vec3 dst)
```
    Parameters:
    
    dst - destination vector to store the forward vector of the look at matrix
    
    Returns:
    
    dst
    
    See Also:
    
    getLookAtMatrix(Mat4x4)
  - getX
```
public final float getX()
```
  - getY
```
public final float getY()
```
  - getZ
```
public final float getZ()
```
  - getW
```
public final float getW()
```

Class Quat

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

IDENTITY

x

y

z

w

Constructor Detail

Quat

Quat

Method Detail

clone

hashCode

equals

toString

set

set

setIdentity

isIdentity

distance

setAnglesXYZ

setAnglesZYX

setAxisAngle

setVectorRotation

setRotationMatrix

setAxis

setLookAtMatrix

multiply

getMatrix

getMatrix3x3

getLookAtMatrix

getAnglesXYZ

getAnglesZYX

getAnglesYX

getAxisAngle

getAngleProjected

getTwistDecomposition

interpolate

slerp

multiply

divide

rotate

rotateTransposed

length

lengthSqr

invert

normalize

conjugate

scale

getAxisX

getAxisY

getAxisZ

getLookAtLeft

getLookAtUp

getLookAtForward

getX

getY

getZ

getW