irr::core::quaternion Class Reference

Quaternion class for representing rotations. More...

#include <quaternion.h>

Public Member Functions
	quaternion ()
	Default Constructor. More...
	quaternion (f32 x, f32 y, f32 z, f32 w)
	Constructor. More...
	quaternion (f32 x, f32 y, f32 z)
	Constructor which converts Euler angles (radians) to a quaternion. More...
	quaternion (const vector3df &vec)
	Constructor which converts Euler angles (radians) to a quaternion. More...
	quaternion (const matrix4 &mat)
	Constructor which converts a matrix to a quaternion. More...
bool	operator== (const quaternion &other) const
	Equality operator. More...
bool	operator!= (const quaternion &other) const
	inequality operator More...
quaternion &	operator= (const quaternion &other)
	Assignment operator. More...
quaternion &	operator= (const matrix4 &other)
	Matrix assignment operator. More...
quaternion	operator+ (const quaternion &other) const
	Add operator. More...
quaternion	operator * (const quaternion &other) const
quaternion	operator * (f32 s) const
	Multiplication operator with scalar. More...
quaternion &	operator *= (f32 s)
	Multiplication operator with scalar. More...
vector3df	operator * (const vector3df &v) const
	Multiplication operator. More...
quaternion &	operator *= (const quaternion &other)
	Multiplication operator. More...
f32	dotProduct (const quaternion &other) const
	Calculates the dot product. More...
quaternion &	set (f32 x, f32 y, f32 z, f32 w)
	Sets new quaternion. More...
quaternion &	set (f32 x, f32 y, f32 z)
	Sets new quaternion based on Euler angles (radians) More...
quaternion &	set (const core::vector3df &vec)
	Sets new quaternion based on Euler angles (radians) More...
quaternion &	set (const core::quaternion &quat)
	Sets new quaternion from other quaternion. More...
bool	equals (const quaternion &other, const f32 tolerance=ROUNDING_ERROR_f32) const
	returns if this quaternion equals the other one, taking floating point rounding errors into account More...
quaternion &	normalize ()
	Normalizes the quaternion. More...
matrix4	getMatrix () const
	Creates a matrix from this quaternion. More...
void	getMatrixFast (matrix4 &dest) const
	Faster method to create a rotation matrix, you should normalize the quaternion before! More...
void	getMatrix (matrix4 &dest, const core::vector3df &translation=core::vector3df()) const
	Creates a matrix from this quaternion. More...
void	getMatrixCenter (matrix4 &dest, const core::vector3df &center, const core::vector3df &translation) const
void	getMatrix_transposed (matrix4 &dest) const
	Creates a matrix from this quaternion. More...
quaternion &	makeInverse ()
	Inverts this quaternion. More...
quaternion &	lerp (quaternion q1, quaternion q2, f32 time)
	Set this quaternion to the linear interpolation between two quaternions. More...
quaternion &	lerpN (quaternion q1, quaternion q2, f32 time)
	Set this quaternion to the linear interpolation between two quaternions and normalize the result. More...
quaternion &	slerp (quaternion q1, quaternion q2, f32 time, f32 threshold=.05f)
	Set this quaternion to the result of the spherical interpolation between two quaternions. More...
quaternion &	fromAngleAxis (f32 angle, const vector3df &axis)
	Set this quaternion to represent a rotation from angle and axis. More...
void	toAngleAxis (f32 &angle, core::vector3df &axis) const
	Fills an angle (radians) around an axis (unit vector) More...
void	toEuler (vector3df &euler) const
	Output this quaternion to an Euler angle (radians) More...
quaternion &	makeIdentity ()
	Set quaternion to identity. More...
quaternion &	rotationFromTo (const vector3df &from, const vector3df &to)
	Set quaternion to represent a rotation from one vector to another. More...

Public Attributes
f32	X
	Quaternion elements. More...
f32	Y
f32	Z
f32	W

Detailed Description

Quaternion class for representing rotations.

It provides cheap combinations and avoids gimbal locks. Also useful for interpolations.

Definition at line 31 of file quaternion.h.

Constructor & Destructor Documentation

quaternion() [1/5]

irr::core::quaternion::quaternion ( )

inline

Default Constructor.

Definition at line 36 of file quaternion.h.

: X(0.0f), Y(0.0f), Z(0.0f), W(1.0f) {}

quaternion() [2/5]

irr::core::quaternion::quaternion ( f32  x, f32  y, f32  z, f32  w  )

inline

Constructor.

Definition at line 39 of file quaternion.h.

: X(x), Y(y), Z(z), W(w) { }

quaternion() [3/5]

irr::core::quaternion::quaternion ( f32  x, f32  y, f32  z  )

inline

Constructor which converts Euler angles (radians) to a quaternion.

Definition at line 208 of file quaternion.h.

{
        set(x,y,z);
}

quaternion() [4/5]

irr::core::quaternion::quaternion ( const vector3df &  vec )

inline

Constructor which converts Euler angles (radians) to a quaternion.

Definition at line 215 of file quaternion.h.

{
        set(vec.X,vec.Y,vec.Z);
}

quaternion() [5/5]

irr::core::quaternion::quaternion ( const matrix4 &  mat )

inline

Constructor which converts a matrix to a quaternion.

Definition at line 222 of file quaternion.h.

{
        (*this) = mat;
}

Member Function Documentation

dotProduct()

f32 irr::core::quaternion::dotProduct ( const quaternion &  other ) const

inline

Calculates the dot product.

Definition at line 631 of file quaternion.h.

{
        return (X * q2.X) + (Y * q2.Y) + (Z * q2.Z) + (W * q2.W);
}

equals()

bool irr::core::quaternion::equals ( const quaternion &  other, const f32  tolerance = ROUNDING_ERROR_f32  ) const

inline

returns if this quaternion equals the other one, taking floating point rounding errors into account

Definition at line 574 of file quaternion.h.

{
        return core::equals( X, other.X, tolerance) &&
                core::equals( Y, other.Y, tolerance) &&
                core::equals( Z, other.Z, tolerance) &&
                core::equals( W, other.W, tolerance);
}

fromAngleAxis()

quaternion & irr::core::quaternion::fromAngleAxis ( f32  angle, const vector3df &  axis  )

inline

Set this quaternion to represent a rotation from angle and axis.

axis must be unit length, angle in radians

Axis must be unit length. The quaternion representing the rotation is q = cos(A/2)+sin(A/2)*(x*i+y*j+z*k).

Parameters

angle	Rotation Angle in radians.
axis	Rotation axis.

Definition at line 638 of file quaternion.h.

{
        const f32 fHalfAngle = 0.5f*angle;
        const f32 fSin = sinf(fHalfAngle);
        W = cosf(fHalfAngle);
        X = fSin*axis.X;
        Y = fSin*axis.Y;
        Z = fSin*axis.Z;
        return *this;
}

getMatrix() [1/2]

matrix4 irr::core::quaternion::getMatrix ( ) const

inline

Creates a matrix from this quaternion.

Definition at line 359 of file quaternion.h.

{
        core::matrix4 m;
        getMatrix(m);
        return m;
}

getMatrix() [2/2]

void irr::core::quaternion::getMatrix ( matrix4 &  dest, const core::vector3df &  center = core::vector3df()  ) const

inline

Creates a matrix from this quaternion.

Creates a matrix from this quaternion

Definition at line 399 of file quaternion.h.

{
        // ok creating a copy may be slower, but at least avoid internal
        // state chance (also because otherwise we cannot keep this method "const").

        quaternion q( *this);
        q.normalize();
        f32 X = q.X;
        f32 Y = q.Y;
        f32 Z = q.Z;
        f32 W = q.W;

        dest[0] = 1.0f - 2.0f*Y*Y - 2.0f*Z*Z;
        dest[1] = 2.0f*X*Y + 2.0f*Z*W;
        dest[2] = 2.0f*X*Z - 2.0f*Y*W;
        dest[3] = 0.0f;

        dest[4] = 2.0f*X*Y - 2.0f*Z*W;
        dest[5] = 1.0f - 2.0f*X*X - 2.0f*Z*Z;
        dest[6] = 2.0f*Z*Y + 2.0f*X*W;
        dest[7] = 0.0f;

        dest[8] = 2.0f*X*Z + 2.0f*Y*W;
        dest[9] = 2.0f*Z*Y - 2.0f*X*W;
        dest[10] = 1.0f - 2.0f*X*X - 2.0f*Y*Y;
        dest[11] = 0.0f;

        dest[12] = center.X;
        dest[13] = center.Y;
        dest[14] = center.Z;
        dest[15] = 1.f;

        dest.setDefinitelyIdentityMatrix ( false );
}

getMatrix_transposed()

void irr::core::quaternion::getMatrix_transposed ( matrix4 &  dest ) const

inline

Creates a matrix from this quaternion.

Definition at line 478 of file quaternion.h.

{
        quaternion q(*this);
        q.normalize();
        f32 X = q.X;
        f32 Y = q.Y;
        f32 Z = q.Z;
        f32 W = q.W;

        dest[0] = 1.0f - 2.0f*Y*Y - 2.0f*Z*Z;
        dest[4] = 2.0f*X*Y + 2.0f*Z*W;
        dest[8] = 2.0f*X*Z - 2.0f*Y*W;
        dest[12] = 0.0f;

        dest[1] = 2.0f*X*Y - 2.0f*Z*W;
        dest[5] = 1.0f - 2.0f*X*X - 2.0f*Z*Z;
        dest[9] = 2.0f*Z*Y + 2.0f*X*W;
        dest[13] = 0.0f;

        dest[2] = 2.0f*X*Z + 2.0f*Y*W;
        dest[6] = 2.0f*Z*Y - 2.0f*X*W;
        dest[10] = 1.0f - 2.0f*X*X - 2.0f*Y*Y;
        dest[14] = 0.0f;

        dest[3] = 0.f;
        dest[7] = 0.f;
        dest[11] = 0.f;
        dest[15] = 1.f;

        dest.setDefinitelyIdentityMatrix(false);
}

getMatrixCenter()

void irr::core::quaternion::getMatrixCenter ( matrix4 &  dest, const core::vector3df &  center, const core::vector3df &  translation  ) const

inline

Creates a matrix from this quaternion Rotate about a center point shortcut for core::quaternion q; q.rotationFromTo ( vin[i].Normal, forward ); q.getMatrixCenter ( lookat, center, newPos );

core::matrix4 m2; m2.setInverseTranslation ( center ); lookat *= m2;

core::matrix4 m3; m2.setTranslation ( newPos ); lookat *= m3;

Creates a matrix from this quaternion Rotate about a center point shortcut for core::quaternion q; q.rotationFromTo(vin[i].Normal, forward); q.getMatrix(lookat, center);

core::matrix4 m2; m2.setInverseTranslation(center); lookat *= m2;

Definition at line 448 of file quaternion.h.

{
        quaternion q(*this);
        q.normalize();
        f32 X = q.X;
        f32 Y = q.Y;
        f32 Z = q.Z;
        f32 W = q.W;

        dest[0] = 1.0f - 2.0f*Y*Y - 2.0f*Z*Z;
        dest[1] = 2.0f*X*Y + 2.0f*Z*W;
        dest[2] = 2.0f*X*Z - 2.0f*Y*W;
        dest[3] = 0.0f;

        dest[4] = 2.0f*X*Y - 2.0f*Z*W;
        dest[5] = 1.0f - 2.0f*X*X - 2.0f*Z*Z;
        dest[6] = 2.0f*Z*Y + 2.0f*X*W;
        dest[7] = 0.0f;

        dest[8] = 2.0f*X*Z + 2.0f*Y*W;
        dest[9] = 2.0f*Z*Y - 2.0f*X*W;
        dest[10] = 1.0f - 2.0f*X*X - 2.0f*Y*Y;
        dest[11] = 0.0f;

        dest.setRotationCenter ( center, translation );
}

getMatrixFast()

void irr::core::quaternion::getMatrixFast ( matrix4 &  dest ) const

inline

Faster method to create a rotation matrix, you should normalize the quaternion before!

Definition at line 368 of file quaternion.h.

{
        // TODO:
        // gpu quaternion skinning => fast Bones transform chain O_O YEAH!
        // http://www.mrelusive.com/publications/papers/SIMD-From-Quaternion-to-Matrix-and-Back.pdf
        dest[0] = 1.0f - 2.0f*Y*Y - 2.0f*Z*Z;
        dest[1] = 2.0f*X*Y + 2.0f*Z*W;
        dest[2] = 2.0f*X*Z - 2.0f*Y*W;
        dest[3] = 0.0f;

        dest[4] = 2.0f*X*Y - 2.0f*Z*W;
        dest[5] = 1.0f - 2.0f*X*X - 2.0f*Z*Z;
        dest[6] = 2.0f*Z*Y + 2.0f*X*W;
        dest[7] = 0.0f;

        dest[8] = 2.0f*X*Z + 2.0f*Y*W;
        dest[9] = 2.0f*Z*Y - 2.0f*X*W;
        dest[10] = 1.0f - 2.0f*X*X - 2.0f*Y*Y;
        dest[11] = 0.0f;

        dest[12] = 0.f;
        dest[13] = 0.f;
        dest[14] = 0.f;
        dest[15] = 1.f;

        dest.setDefinitelyIdentityMatrix(false);
}

lerp()

quaternion & irr::core::quaternion::lerp ( quaternion  q1, quaternion  q2, f32  time  )

inline

Set this quaternion to the linear interpolation between two quaternions.

NOTE: lerp result is not a normalized quaternion. In most cases you will want to use lerpN instead as most other quaternion functions expect to work with a normalized quaternion.

Parameters

q1	First quaternion to be interpolated.
q2	Second quaternion to be interpolated.
time	Progress of interpolation. For time=0 the result is q1, for time=1 the result is q2. Otherwise interpolation between q1 and q2. Result is not normalized.

Definition at line 592 of file quaternion.h.

{
        const f32 scale = 1.0f - time;
        return (*this = (q1*scale) + (q2*time));
}

lerpN()

quaternion & irr::core::quaternion::lerpN ( quaternion  q1, quaternion  q2, f32  time  )

inline

Set this quaternion to the linear interpolation between two quaternions and normalize the result.

Parameters

q1	First quaternion to be interpolated.
q2	Second quaternion to be interpolated.
time	Progress of interpolation. For time=0 the result is q1, for time=1 the result is q2. Otherwise interpolation between q1 and q2. Result is normalized.

Definition at line 599 of file quaternion.h.

{
        const f32 scale = 1.0f - time;
        return (*this = ((q1*scale) + (q2*time)).normalize() );
}

makeIdentity()

core::quaternion & irr::core::quaternion::makeIdentity ( )

inline

Set quaternion to identity.

Definition at line 724 of file quaternion.h.

{
        W = 1.f;
        X = 0.f;
        Y = 0.f;
        Z = 0.f;
        return *this;
}

makeInverse()

quaternion & irr::core::quaternion::makeInverse ( )

inline

Inverts this quaternion.

Definition at line 512 of file quaternion.h.

{
        X = -X; Y = -Y; Z = -Z;
        return *this;
}

normalize()

quaternion & irr::core::quaternion::normalize ( )

inline

Normalizes the quaternion.

Definition at line 584 of file quaternion.h.

{
        // removed conditional branch since it may slow down and anyway the condition was
        // false even after normalization in some cases.
        return (*this *= (f32)reciprocal_squareroot ( (f64)(X*X + Y*Y + Z*Z + W*W) ));
}

operator *() [1/3]

quaternion irr::core::quaternion::operator * ( const quaternion &  other ) const

inline

Multiplication operator Be careful, unfortunately the operator order here is opposite of that in CMatrix4::operator*

Definition at line 315 of file quaternion.h.

{
        quaternion tmp;

        tmp.W = (other.W * W) - (other.X * X) - (other.Y * Y) - (other.Z * Z);
        tmp.X = (other.W * X) + (other.X * W) + (other.Y * Z) - (other.Z * Y);
        tmp.Y = (other.W * Y) + (other.Y * W) + (other.Z * X) - (other.X * Z);
        tmp.Z = (other.W * Z) + (other.Z * W) + (other.X * Y) - (other.Y * X);

        return tmp;
}

operator *() [2/3]

quaternion irr::core::quaternion::operator * ( f32  s ) const

inline

Multiplication operator with scalar.

Definition at line 329 of file quaternion.h.

{
        return quaternion(s*X, s*Y, s*Z, s*W);
}

operator *() [3/3]

vector3df irr::core::quaternion::operator * ( const vector3df &  v ) const

inline

Multiplication operator.

Definition at line 709 of file quaternion.h.

{
        // nVidia SDK implementation

        vector3df uv, uuv;
        const vector3df qvec(X, Y, Z);
        uv = qvec.crossProduct(v);
        uuv = qvec.crossProduct(uv);
        uv *= (2.0f * W);
        uuv *= 2.0f;

        return v + uv + uuv;
}

operator *=() [1/2]

quaternion & irr::core::quaternion::operator *= ( f32  s )

inline

Multiplication operator with scalar.

Definition at line 336 of file quaternion.h.

{
        X*=s;
        Y*=s;
        Z*=s;
        W*=s;
        return *this;
}

operator *=() [2/2]

quaternion & irr::core::quaternion::operator *= ( const quaternion &  other )

inline

Multiplication operator.

Definition at line 346 of file quaternion.h.

{
        return (*this = other * (*this));
}

operator!=()

bool irr::core::quaternion::operator!= ( const quaternion &  other ) const

inline

inequality operator

Definition at line 238 of file quaternion.h.

{
        return !(*this == other);
}

operator+()

quaternion irr::core::quaternion::operator+ ( const quaternion &  other ) const

inline

Add operator.

Definition at line 352 of file quaternion.h.

{
        return quaternion(X+b.X, Y+b.Y, Z+b.Z, W+b.W);
}

operator=() [1/2]

quaternion & irr::core::quaternion::operator= ( const quaternion &  other )

inline

Assignment operator.

Definition at line 244 of file quaternion.h.

{
        X = other.X;
        Y = other.Y;
        Z = other.Z;
        W = other.W;
        return *this;
}

operator=() [2/2]

quaternion & irr::core::quaternion::operator= ( const matrix4 &  other )

inline

Matrix assignment operator.

Definition at line 255 of file quaternion.h.

{
        const f32 diag = m[0] + m[5] + m[10] + 1;

        if( diag > 0.0f )
        {
                const f32 scale = sqrtf(diag) * 2.0f; // get scale from diagonal

                // TODO: speed this up
                X = (m[6] - m[9]) / scale;
                Y = (m[8] - m[2]) / scale;
                Z = (m[1] - m[4]) / scale;
                W = 0.25f * scale;
        }
        else
        {
                if (m[0]>m[5] && m[0]>m[10])
                {
                        // 1st element of diag is greatest value
                        // find scale according to 1st element, and double it
                        const f32 scale = sqrtf(1.0f + m[0] - m[5] - m[10]) * 2.0f;

                        // TODO: speed this up
                        X = 0.25f * scale;
                        Y = (m[4] + m[1]) / scale;
                        Z = (m[2] + m[8]) / scale;
                        W = (m[6] - m[9]) / scale;
                }
                else if (m[5]>m[10])
                {
                        // 2nd element of diag is greatest value
                        // find scale according to 2nd element, and double it
                        const f32 scale = sqrtf(1.0f + m[5] - m[0] - m[10]) * 2.0f;

                        // TODO: speed this up
                        X = (m[4] + m[1]) / scale;
                        Y = 0.25f * scale;
                        Z = (m[9] + m[6]) / scale;
                        W = (m[8] - m[2]) / scale;
                }
                else
                {
                        // 3rd element of diag is greatest value
                        // find scale according to 3rd element, and double it
                        const f32 scale = sqrtf(1.0f + m[10] - m[0] - m[5]) * 2.0f;

                        // TODO: speed this up
                        X = (m[8] + m[2]) / scale;
                        Y = (m[9] + m[6]) / scale;
                        Z = 0.25f * scale;
                        W = (m[1] - m[4]) / scale;
                }
        }

        return normalize();
}

operator==()

bool irr::core::quaternion::operator== ( const quaternion &  other ) const

inline

Equality operator.

Definition at line 229 of file quaternion.h.

{
        return ((X == other.X) &&
                (Y == other.Y) &&
                (Z == other.Z) &&
                (W == other.W));
}

rotationFromTo()

core::quaternion & irr::core::quaternion::rotationFromTo ( const vector3df &  from, const vector3df &  to  )

inline

Set quaternion to represent a rotation from one vector to another.

Definition at line 733 of file quaternion.h.

{
        // Based on Stan Melax's article in Game Programming Gems
        // Copy, since cannot modify local
        vector3df v0 = from;
        vector3df v1 = to;
        v0.normalize();
        v1.normalize();

        const f32 d = v0.dotProduct(v1);
        if (d >= 1.0f) // If dot == 1, vectors are the same
        {
                return makeIdentity();
        }
        else if (d <= -1.0f) // exactly opposite
        {
                core::vector3df axis(1.0f, 0.f, 0.f);
                axis = axis.crossProduct(v0);
                if (axis.getLength()==0)
                {
                        axis.set(0.f,1.f,0.f);
                        axis = axis.crossProduct(v0);
                }
                // same as fromAngleAxis(core::PI, axis).normalize();
                return set(axis.X, axis.Y, axis.Z, 0).normalize();
        }

        const f32 s = sqrtf( (1+d)*2 ); // optimize inv_sqrt
        const f32 invs = 1.f / s;
        const vector3df c = v0.crossProduct(v1)*invs;
        return set(c.X, c.Y, c.Z, s * 0.5f).normalize();
}

set() [1/4]

quaternion & irr::core::quaternion::set ( f32  x, f32  y, f32  z, f32  w  )

inline

Sets new quaternion.

Definition at line 520 of file quaternion.h.

{
        X = x;
        Y = y;
        Z = z;
        W = w;
        return *this;
}

set() [2/4]

quaternion & irr::core::quaternion::set ( f32  x, f32  y, f32  z  )

inline

Sets new quaternion based on Euler angles (radians)

Definition at line 531 of file quaternion.h.

{
        f64 angle;

        angle = x * 0.5;
        const f64 sr = sin(angle);
        const f64 cr = cos(angle);

        angle = y * 0.5;
        const f64 sp = sin(angle);
        const f64 cp = cos(angle);

        angle = z * 0.5;
        const f64 sy = sin(angle);
        const f64 cy = cos(angle);

        const f64 cpcy = cp * cy;
        const f64 spcy = sp * cy;
        const f64 cpsy = cp * sy;
        const f64 spsy = sp * sy;

        X = (f32)(sr * cpcy - cr * spsy);
        Y = (f32)(cr * spcy + sr * cpsy);
        Z = (f32)(cr * cpsy - sr * spcy);
        W = (f32)(cr * cpcy + sr * spsy);

        return normalize();
}

set() [3/4]

quaternion & irr::core::quaternion::set ( const core::vector3df &  vec )

inline

Sets new quaternion based on Euler angles (radians)

Definition at line 561 of file quaternion.h.

{
        return set( vec.X, vec.Y, vec.Z);
}

set() [4/4]

quaternion & irr::core::quaternion::set ( const core::quaternion &  quat )

inline

Sets new quaternion from other quaternion.

Definition at line 567 of file quaternion.h.

{
        return (*this=quat);
}

slerp()

quaternion & irr::core::quaternion::slerp ( quaternion  q1, quaternion  q2, f32  time, f32  threshold = .05f  )

inline

Set this quaternion to the result of the spherical interpolation between two quaternions.

Parameters

q1	First quaternion to be interpolated.
q2	Second quaternion to be interpolated.
time	Progress of interpolation. For time=0 the result is q1, for time=1 the result is q2. Otherwise interpolation between q1 and q2.
threshold	To avoid inaccuracies at the end (time=1) the interpolation switches to linear interpolation at some point. This value defines how much of the remaining interpolation will be calculated with lerp. Everything from 1-threshold up will be linear interpolation.

Definition at line 606 of file quaternion.h.

{
        f32 angle = q1.dotProduct(q2);

        // make sure we use the short rotation
        if (angle < 0.0f)
        {
                q1 *= -1.0f;
                angle *= -1.0f;
        }

        if (angle <= (1-threshold)) // spherical interpolation
        {
                const f32 theta = acosf(angle);
                const f32 invsintheta = reciprocal(sinf(theta));
                const f32 scale = sinf(theta * (1.0f-time)) * invsintheta;
                const f32 invscale = sinf(theta * time) * invsintheta;
                return (*this = (q1*scale) + (q2*invscale));
        }
        else // linear interpolation
                return lerpN(q1,q2,time);
}

toAngleAxis()

void irr::core::quaternion::toAngleAxis ( f32 &  angle, core::vector3df &  axis  ) const

inline

Fills an angle (radians) around an axis (unit vector)

Definition at line 650 of file quaternion.h.

{
        const f32 scale = sqrtf(X*X + Y*Y + Z*Z);

        if (core::iszero(scale) || W > 1.0f || W < -1.0f)
        {
                angle = 0.0f;
                axis.X = 0.0f;
                axis.Y = 1.0f;
                axis.Z = 0.0f;
        }
        else
        {
                const f32 invscale = reciprocal(scale);
                angle = 2.0f * acosf(W);
                axis.X = X * invscale;
                axis.Y = Y * invscale;
                axis.Z = Z * invscale;
        }
}

toEuler()

void irr::core::quaternion::toEuler ( vector3df &  euler ) const

inline

Output this quaternion to an Euler angle (radians)

Definition at line 671 of file quaternion.h.

{
        const f64 sqw = W*W;
        const f64 sqx = X*X;
        const f64 sqy = Y*Y;
        const f64 sqz = Z*Z;
        const f64 test = 2.0 * (Y*W - X*Z);

        if (core::equals(test, 1.0, 0.000001))
        {
                // heading = rotation about z-axis
                euler.Z = (f32) (-2.0*atan2(X, W));
                // bank = rotation about x-axis
                euler.X = 0;
                // attitude = rotation about y-axis
                euler.Y = (f32) (core::PI64/2.0);
        }
        else if (core::equals(test, -1.0, 0.000001))
        {
                // heading = rotation about z-axis
                euler.Z = (f32) (2.0*atan2(X, W));
                // bank = rotation about x-axis
                euler.X = 0;
                // attitude = rotation about y-axis
                euler.Y = (f32) (core::PI64/-2.0);
        }
        else
        {
                // heading = rotation about z-axis
                euler.Z = (f32) atan2(2.0 * (X*Y +Z*W),(sqx - sqy - sqz + sqw));
                // bank = rotation about x-axis
                euler.X = (f32) atan2(2.0 * (Y*Z +X*W),(-sqx - sqy + sqz + sqw));
                // attitude = rotation about y-axis
                euler.Y = (f32) asin( clamp(test, -1.0, 1.0) );
        }
}

Member Data Documentation

W

f32 irr::core::quaternion::W

Definition at line 203 of file quaternion.h.

X

f32 irr::core::quaternion::X

Quaternion elements.

Definition at line 200 of file quaternion.h.

Y

f32 irr::core::quaternion::Y

Definition at line 201 of file quaternion.h.

Z

f32 irr::core::quaternion::Z

Definition at line 202 of file quaternion.h.

---

The documentation for this class was generated from the following file:

• include/irrlicht/quaternion.h