org.joml.Quaterniondc Maven / Gradle / Ivy
/*
* The MIT License
*
* Copyright (c) 2015-2019 JOML
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.joml;
/**
* Interface to a read-only view of a quaternion of double-precision floats.
*
* @author Kai Burjack
*/
public interface Quaterniondc {
/**
* @return the first component of the vector part
*/
double x();
/**
* @return the second component of the vector part
*/
double y();
/**
* @return the third component of the vector part
*/
double z();
/**
* @return the real/scalar part of the quaternion
*/
double w();
/**
* Normalize this quaternion and store the result in dest.
*
* @param dest
* will hold the result
* @return dest
*/
Quaterniond normalize(Quaterniond dest);
/**
* Add the quaternion (x, y, z, w) to this quaternion and store the result in dest.
*
* @param x
* the x component of the vector part
* @param y
* the y component of the vector part
* @param z
* the z component of the vector part
* @param w
* the real/scalar component
* @param dest
* will hold the result
* @return dest
*/
Quaterniond add(double x, double y, double z, double w, Quaterniond dest);
/**
* Add q2 to this quaternion and store the result in dest.
*
* @param q2
* the quaternion to add to this
* @param dest
* will hold the result
* @return dest
*/
Quaterniond add(Quaterniondc q2, Quaterniond dest);
/**
* Return the dot product of this {@link Quaterniond} and otherQuat.
*
* @param otherQuat
* the other quaternion
* @return the dot product
*/
double dot(Quaterniondc otherQuat);
/**
* Return the angle in radians represented by this quaternion rotation.
*
* @return the angle in radians
*/
double angle();
/**
* Set the given destination matrix to the rotation represented by this.
*
* @see Matrix3d#set(Quaterniondc)
*
* @param dest
* the matrix to write the rotation into
* @return the passed in destination
*/
Matrix3d get(Matrix3d dest);
/**
* Set the given destination matrix to the rotation represented by this.
*
* @see Matrix3f#set(Quaterniondc)
*
* @param dest
* the matrix to write the rotation into
* @return the passed in destination
*/
Matrix3f get(Matrix3f dest);
/**
* Set the given destination matrix to the rotation represented by this.
*
* @see Matrix4d#set(Quaterniondc)
*
* @param dest
* the matrix to write the rotation into
* @return the passed in destination
*/
Matrix4d get(Matrix4d dest);
/**
* Set the given destination matrix to the rotation represented by this.
*
* @see Matrix4f#set(Quaterniondc)
*
* @param dest
* the matrix to write the rotation into
* @return the passed in destination
*/
Matrix4f get(Matrix4f dest);
/**
* Set the given {@link Quaterniond} to the values of this.
*
* @param dest
* the {@link Quaterniond} to set
* @return the passed in destination
*/
Quaterniond get(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.
*
* @param q
* the quaternion to multiply this by
* @param dest
* will hold the result
* @return dest
*/
Quaterniond mul(Quaterniondc q, 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.
*
* @param qx
* the x component of the quaternion to multiply this by
* @param qy
* the y component of the quaternion to multiply this by
* @param qz
* the z component of the quaternion to multiply this by
* @param qw
* the w component of the quaternion to multiply this by
* @param dest
* will hold the result
* @return dest
*/
Quaterniond mul(double qx, double qy, double qz, double qw, 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.
*
* @param q
* the quaternion to pre-multiply this by
* @param dest
* will hold the result
* @return dest
*/
Quaterniond premul(Quaterniondc q, 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.
*
* @param qx
* the x component of the quaternion to multiply this by
* @param qy
* the y component of the quaternion to multiply this by
* @param qz
* the z component of the quaternion to multiply this by
* @param qw
* the w component of the quaternion to multiply this by
* @param dest
* will hold the result
* @return dest
*/
Quaterniond premul(double qx, double qy, double qz, double qw, Quaterniond dest);
/**
* Transform the given vector by this quaternion.
* This will apply the rotation described by this quaternion to the given vector.
*
* @param vec
* the vector to transform
* @return vec
*/
Vector3d transform(Vector3d vec);
/**
* Transform the vector (1, 0, 0) by this quaternion.
*
* @param dest
* will hold the result
* @return dest
*/
Vector3d transformPositiveX(Vector3d dest);
/**
* Transform the vector (1, 0, 0) by this quaternion.
*
* Only the first three components of the given 4D vector are modified.
*
* @param dest
* will hold the result
* @return dest
*/
Vector4d transformPositiveX(Vector4d 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/
*
* @param dest
* will hold the result
* @return dest
*/
Vector3d transformUnitPositiveX(Vector3d 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/
*
* @param dest
* will hold the result
* @return dest
*/
Vector4d transformUnitPositiveX(Vector4d dest);
/**
* Transform the vector (0, 1, 0) by this quaternion.
*
* @param dest
* will hold the result
* @return dest
*/
Vector3d transformPositiveY(Vector3d dest);
/**
* Transform the vector (0, 1, 0) by this quaternion.
*
* Only the first three components of the given 4D vector are modified.
*
* @param dest
* will hold the result
* @return dest
*/
Vector4d transformPositiveY(Vector4d 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/
*
* @param dest
* will hold the result
* @return dest
*/
Vector3d transformUnitPositiveY(Vector3d 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/
*
* @param dest
* will hold the result
* @return dest
*/
Vector4d transformUnitPositiveY(Vector4d dest);
/**
* Transform the vector (0, 0, 1) by this quaternion.
*
* @param dest
* will hold the result
* @return dest
*/
Vector3d transformPositiveZ(Vector3d dest);
/**
* Transform the vector (0, 0, 1) by this quaternion.
*
* Only the first three components of the given 4D vector are modified.
*
* @param dest
* will hold the result
* @return dest
*/
Vector4d transformPositiveZ(Vector4d 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/
*
* @param dest
* will hold the result
* @return dest
*/
Vector3d transformUnitPositiveZ(Vector3d 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/
*
* @param dest
* will hold the result
* @return dest
*/
Vector4d transformUnitPositiveZ(Vector4d dest);
/**
* 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.
*
* @param vec
* the vector to transform
* @return vec
*/
Vector4d transform(Vector4d vec);
/**
* 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.
*
* @param vec
* the vector to transform
* @param dest
* will hold the result
* @return dest
*/
Vector3d transform(Vector3dc vec, 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.
*
* @param x
* the x coordinate of the vector to transform
* @param y
* the y coordinate of the vector to transform
* @param z
* the z coordinate of the vector to transform
* @param dest
* will hold the result
* @return dest
*/
Vector3d transform(double x, double y, double z, 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.
*
* Only the first three components of the given 4D vector are being used and set on the destination.
*
* @param vec
* the vector to transform
* @param dest
* will hold the result
* @return dest
*/
Vector4d transform(Vector4dc vec, 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.
*
* @param x
* the x coordinate of the vector to transform
* @param y
* the y coordinate of the vector to transform
* @param z
* the z coordinate of the vector to transform
* @param dest
* will hold the result
* @return dest
*/
Vector4d transform(double x, double y, double z, Vector4d dest);
/**
* Invert this quaternion and store the {@link #normalize(Quaterniond) normalized} result in dest.
*
* If this quaternion is already normalized, then {@link #conjugate(Quaterniond)} should be used instead.
*
* @see #conjugate(Quaterniond)
*
* @param dest
* will hold the result
* @return dest
*/
Quaterniond invert(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.
*
* @param b
* the {@link Quaterniondc} to divide this by
* @param dest
* will hold the result
* @return dest
*/
Quaterniond div(Quaterniondc b, Quaterniond dest);
/**
* Conjugate this quaternion and store the result in dest.
*
* @param dest
* will hold the result
* @return dest
*/
Quaterniond conjugate(Quaterniond dest);
/**
* Return the square of the length of this quaternion.
*
* @return the length
*/
double lengthSquared();
/**
* Interpolate between this {@link #normalize(Quaterniond) unit} quaternion and the specified
* target {@link #normalize(Quaterniond) 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
*
* @param target
* the target of the interpolation, which should be reached with alpha = 1.0
* @param alpha
* the interpolation factor, within [0..1]
* @param dest
* will hold the result
* @return dest
*/
Quaterniond slerp(Quaterniondc target, double alpha, 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.
*
* @param factor
* the scaling factor
* @param dest
* will hold the result
* @return dest
*/
Quaterniond scale(double factor, 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/
*
* @param dt
* the delta time
* @param vx
* the angular velocity around the x axis
* @param vy
* the angular velocity around the y axis
* @param vz
* the angular velocity around the z axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond integrate(double dt, double vx, double vy, double vz, 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
*
* @param q
* the other quaternion
* @param factor
* the interpolation factor. It is between 0.0 and 1.0
* @param dest
* will hold the result
* @return dest
*/
Quaterniond nlerp(Quaterniondc q, double factor, 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
* {@link #slerp(Quaterniondc, double, Quaterniond) 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.
*
* @param q
* the other quaternion
* @param alpha
* the interpolation factor, between 0.0 and 1.0
* @param dotThreshold
* the threshold for the dot product of this and q above which this method performs another iteration
* of a small-step linear interpolation
* @param dest
* will hold the result
* @return dest
*/
Quaterniond nlerpIterative(Quaterniondc q, double alpha, double dotThreshold, 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!
*
* Reference: http://answers.unity3d.com
*
* @see #lookAlong(double, double, double, double, double, double, Quaterniond)
*
* @param dir
* the direction to map to the positive Z axis
* @param up
* the vector which will be mapped to a vector parallel to the plane
* spanned by the given dir and up
* @param dest
* will hold the result
* @return 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.
*
* 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
*
* @param dirX
* the x-coordinate of the direction to look along
* @param dirY
* the y-coordinate of the direction to look along
* @param dirZ
* the z-coordinate of the direction to look along
* @param upX
* the x-coordinate of the up vector
* @param upY
* the y-coordinate of the up vector
* @param upZ
* the z-coordinate of the up vector
* @param dest
* will hold the result
* @return dest
*/
Quaterniond lookAlong(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, 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 {@link #invert(Quaterniond) inverse} of T.
*
* @param other
* the other quaternion
* @param dest
* will hold the result
* @return dest
*/
Quaterniond difference(Quaterniondc other, 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
*
* @param fromDirX
* the x-coordinate of the direction to rotate into the destination direction
* @param fromDirY
* the y-coordinate of the direction to rotate into the destination direction
* @param fromDirZ
* the z-coordinate of the direction to rotate into the destination direction
* @param toDirX
* the x-coordinate of the direction to rotate to
* @param toDirY
* the y-coordinate of the direction to rotate to
* @param toDirZ
* the z-coordinate of the direction to rotate to
* @param dest
* will hold the result
* @return 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.
*
* 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!
*
* @see #rotateTo(double, double, double, double, double, double, Quaterniond)
*
* @param fromDir
* the starting direction
* @param toDir
* the destination direction
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateTo(Vector3dc fromDir, Vector3dc toDir, 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!
*
* @param angle
* the angle in radians to rotate about the x axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateX(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!
*
* @param angle
* the angle in radians to rotate about the y axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateY(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!
*
* @param angle
* the angle in radians to rotate about the z axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateZ(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!
*
* @param angle
* the angle in radians to rotate about the local x axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateLocalX(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!
*
* @param angle
* the angle in radians to rotate about the local y axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateLocalY(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!
*
* @param angle
* the angle in radians to rotate about the local z axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateLocalZ(double angle, 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!
*
* @param angleX
* the angle in radians to rotate about the x axis
* @param angleY
* the angle in radians to rotate about the y axis
* @param angleZ
* the angle in radians to rotate about the z axis
* @param dest
* will hold the result
* @return 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 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!
*
* @param angleZ
* the angle in radians to rotate about the z axis
* @param angleY
* the angle in radians to rotate about the y axis
* @param angleX
* the angle in radians to rotate about the x axis
* @param dest
* will hold the result
* @return 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 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!
*
* @param angleY
* the angle in radians to rotate about the y axis
* @param angleX
* the angle in radians to rotate about the x axis
* @param angleZ
* the angle in radians to rotate about the z axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateYXZ(double angleY, double angleX, double angleZ, Quaterniond dest);
/**
* Get the euler angles in radians in rotation sequence XYZ of this quaternion and store them in the
* provided parameter eulerAngles.
*
* @param eulerAngles
* will hold the euler angles in radians
* @return the passed in vector
*/
Vector3d getEulerAnglesXYZ(Vector3d eulerAngles);
/**
* 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!
*
* @param angle
* the angle in radians to rotate about the specified axis
* @param axisX
* the x coordinate of the rotation axis
* @param axisY
* the y coordinate of the rotation axis
* @param axisZ
* the z coordinate of the rotation axis
* @param dest
* will hold the result
* @return 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.
*
* 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!
*
* @see #rotateAxis(double, double, double, double, Quaterniond)
*
* @param angle
* the angle in radians to rotate about the specified axis
* @param axis
* the rotation axis
* @param dest
* will hold the result
* @return dest
*/
Quaterniond rotateAxis(double angle, Vector3dc axis, Quaterniond dest);
/**
* 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));
*
*
* @param dir
* will hold the direction of +X
* @return dir
*/
Vector3d positiveX(Vector3d dir);
/**
* Obtain the direction of +X before the rotation transformation represented by this normalized quaternion is applied.
* The quaternion must be {@link #normalize(Quaterniond) 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));
*
*
* @param dir
* will hold the direction of +X
* @return dir
*/
Vector3d normalizedPositiveX(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));
*
*
* @param dir
* will hold the direction of +Y
* @return dir
*/
Vector3d positiveY(Vector3d dir);
/**
* Obtain the direction of +Y before the rotation transformation represented by this normalized quaternion is applied.
* The quaternion must be {@link #normalize(Quaterniond) 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));
*
*
* @param dir
* will hold the direction of +Y
* @return dir
*/
Vector3d normalizedPositiveY(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));
*
*
* @param dir
* will hold the direction of +Z
* @return dir
*/
Vector3d positiveZ(Vector3d dir);
/**
* Obtain the direction of +Z before the rotation transformation represented by this normalized quaternion is applied.
* The quaternion must be {@link #normalize(Quaterniond) 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));
*
*
* @param dir
* will hold the direction of +Z
* @return dir
*/
Vector3d normalizedPositiveZ(Vector3d dir);
}