template <typename F>
struct Quat_tpl {
  Vec3_tpl v;
  F w;
  template <typename F>
struct QuatT_tpl {
    Quat_tpl q;
    Vec3_tpl t;
    template <typename F>
struct QuatTS_tpl {
      Quat_tpl q;
      Vec3_tpl t;
      F s;
      template <typename F>
struct QuatTNS_tpl {
        Quat_tpl q;
        Vec3_tpl t;
        Vec3_tpl s;
        template <typename F>
struct DualQuat_tpl {
          Quat_tpl nq;
          Quat_tpl dq;
        };
      };
    };
  };
};

Cry_Quat.h

Quaternion

template <typename F>
struct QuatT_tpl {
  Quat_tpl q;
  Vec3_tpl t;
  template <typename F>
struct QuatTS_tpl {
    Quat_tpl q;
    Vec3_tpl t;
    F s;
    template <typename F>
struct QuatTNS_tpl {
      Quat_tpl q;
      Vec3_tpl t;
      Vec3_tpl s;
      template <typename F>
struct DualQuat_tpl {
        Quat_tpl nq;
        Quat_tpl dq;
      };
    };
  };
};

Cry_Quat.h

Quaternion with translation vector

template <typename F>
struct QuatTS_tpl {
  Quat_tpl q;
  Vec3_tpl t;
  F s;
  template <typename F>
struct QuatTNS_tpl {
    Quat_tpl q;
    Vec3_tpl t;
    Vec3_tpl s;
    template <typename F>
struct DualQuat_tpl {
      Quat_tpl nq;
      Quat_tpl dq;
    };
  };
};

Cry_Quat.h

Quaternion with translation vector and scale Similar to QuatT, but s is not ignored. Most functions then differ, so we don't inherit.

template <typename F>
struct QuatTNS_tpl {
  Quat_tpl q;
  Vec3_tpl t;
  Vec3_tpl s;
  template <typename F>
struct DualQuat_tpl {
    Quat_tpl nq;
    Quat_tpl dq;
  };
};

Cry_Quat.h

Quaternion with translation vector and non-uniform scale

template <typename F>
struct DualQuat_tpl {
  Quat_tpl nq;
  Quat_tpl dq;
};

Cry_Quat.h

Dual Quaternion

Quat_tpl dq;

Quat_tpl nq;

template <class F1, class F2> DualQuat_tpl operator *(const DualQuat_tpl & a, const DualQuat_tpl & b);

template <class F1, class F2> DualQuat_tpl operator *(const DualQuat_tpl & l, const F2 r);

template <class F1, class F2> Vec3_tpl operator *(const DualQuat_tpl & dq, const Vec3_tpl & v);

template <class F1, class F2> DualQuat_tpl operator +(const DualQuat_tpl & l, const DualQuat_tpl & r);

template <class F1,class F2> void operator +=(DualQuat_tpl & l, const DualQuat_tpl & r);

DualQuat_tpl();

template <typename F1> DualQuat_tpl(const DualQuat_tpl& QDual);

DualQuat_tpl(const Matrix34_tpl& m34);

DualQuat_tpl(const QuatT_tpl& qt);

DualQuat_tpl(const Quat_tpl& q, const Vec3_tpl& t);

DualQuat_tpl(type_identity);

DualQuat_tpl(type_zero);

void Normalize();

void SetIdentity();

void SetZero();

typedef DualQuat_tpl DualQuat;

always 32 bit

typedef DualQuat_tpl DualQuatd;

always 64 bit

typedef DualQuat_tpl DualQuatr;

variable float precision. depending on the target system it can be between 32, 64 or 80 bit

Quat_tpl q;

Vec3_tpl s;

Vec3_tpl t;

template <class F1,class F2> QuatTNS_tpl operator *(const QuatTNS_tpl & a, const QuatTNS_tpl & b);

!

• Implements the multiplication operator: QuatTNS=QuatTNS*QuatTNS

template <class F1,class F2> QuatTNS_tpl operator *(const QuatTNS_tpl & a, const QuatT_tpl & b);

template <class F1,class F2> QuatTNS_tpl operator *(const QuatTNS_tpl & a, const Quat_tpl & b);

template <class F1,class F2> Vec3_tpl operator *(const QuatTNS_tpl & q, const Vec3_tpl & v);

!

• post-multiply of a QuatTNS and a Vec3 (3D rotations with quaternions)

template <class F1,class F2> QuatTNS_tpl operator *(const QuatT_tpl & a, const QuatTNS_tpl & b);

template <class F1,class F2> QuatTNS_tpl operator *(const Quat_tpl & a, const QuatTNS_tpl & b);

QuatTNS_tpl& operator =(const QuatT_tpl & qt);

static QuatTNS_tpl CreateNLerp(const QuatTNS_tpl & p, const QuatTNS_tpl & q, F t);

DEFINE_ALIGNED_DATA(QuatTNS, QuatTNSA, 16);

alligned versions

DEFINE_ALIGNED_DATA(QuatTNS_f64, QuatTNS_f64A, 64);

DEFINE_ALIGNED_DATA(QuatTNSr, QuatTNSrA, 64);

Vec3_tpl GetColumn0() const;

Vec3_tpl GetColumn1() const;

Vec3_tpl GetColumn2() const;

Vec3_tpl GetColumn3() const;

QuatTNS_tpl GetInverted() const;

Vec3_tpl GetRow0() const;

Vec3_tpl GetRow1() const;

Vec3_tpl GetRow2() const;

void Invert();

static bool IsEquivalent(const QuatTNS_tpl& qts1, const QuatTNS_tpl& qts2, F qe = RAD_EPSILON, F ve = VEC_EPSILON);

bool IsValid(F e = VEC_EPSILON) const;

QuatTNS_tpl();

explicit QuatTNS_tpl(const Matrix34_tpl& m);

template <typename F1> QuatTNS_tpl(const QuatTS_tpl& qts);

CONSTRUCTOR: implement the copy/casting/assignment constructor:

QuatTNS_tpl(const QuatT_tpl& qp);

QuatTNS_tpl(const Quat_tpl& quat, const Vec3_tpl& trans, const Vec3_tpl& scale = Vec3_tpl(1));

QuatTNS_tpl(type_identity);

void SetIdentity();

void SetNLerp(const QuatTNS_tpl & p, const QuatTNS_tpl & tq, F ti);

!

• linear-interpolation between quaternions (nlerp)

*

• Example:
• CQuaternion result,p,q;
• result=qlerp( p, q, 0.5f );

typedef QuatTNS_tpl QuatTNS;

typedef QuatTNS_tpl QuatTNS_f64;

typedef QuatTNS_tpl QuatTNSr;

Quat_tpl q;

F s;

Vec3_tpl t;

template <class F1,class F2> QuatTS_tpl operator *(const QuatTS_tpl & a, const QuatTS_tpl & b);

!

• Implements the multiplication operator: QuatTS=QuatTS*QuatTS

template <class F1,class F2> QuatTS_tpl operator *(const QuatTS_tpl & a, const QuatT_tpl & b);

template <class F1,class F2> QuatTS_tpl operator *(const QuatTS_tpl & a, const Quat_tpl & b);

template <class F,class F2> Vec3_tpl operator *(const QuatTS_tpl & q, const Vec3_tpl & v);

!

• post-multiply of a QuatT and a Vec3 (3D rotations with quaternions)

template <class F1,class F2> QuatTS_tpl operator *(const QuatT_tpl & a, const QuatTS_tpl & b);

template <class F1,class F2> QuatTS_tpl operator *(const Quat_tpl & a, const QuatTS_tpl & b);

QuatTS_tpl& operator =(const QuatT_tpl & qt);

static QuatTS_tpl CreateNLerp(const QuatTS_tpl & p, const QuatTS_tpl & q, F t);

DEFINE_ALIGNED_DATA(QuatTS, QuatTSA, 16);

typedef __declspec(align(16)) Quat_tpl

DEFINE_ALIGNED_DATA(QuatTSd, QuatTSrA, 64);

typedef __declspec(align(16)) QuatTS_tpl

Vec3_tpl GetColumn0() const;

Vec3_tpl GetColumn1() const;

Vec3_tpl GetColumn2() const;

Vec3_tpl GetColumn3() const;

QuatTS_tpl GetInverted() const;

Vec3_tpl GetRow0() const;

Vec3_tpl GetRow1() const;

Vec3_tpl GetRow2() const;

void Invert();

static bool IsEquivalent(const QuatTS_tpl& qts1, const QuatTS_tpl& qts2, F qe = RAD_EPSILON, F ve = VEC_EPSILON);

bool IsValid(F e = VEC_EPSILON) const;

QuatTS_tpl();

explicit QuatTS_tpl(const Matrix34_tpl& m);

template <typename F1> QuatTS_tpl(const QuatTS_tpl& qts);

CONSTRUCTOR: implement the copy/casting/assignment constructor:

QuatTS_tpl(const QuatT_tpl& qp);

QuatTS_tpl(const Quat_tpl& quat, const Vec3_tpl& trans, F scale = 1);

QuatTS_tpl(type_identity);

void SetIdentity();

void SetNLerp(const QuatTS_tpl & p, const QuatTS_tpl & tq, F ti);

!

• linear-interpolation between quaternions (nlerp)

*

• Example:
• CQuaternion result,p,q;
• result=qlerp( p, q, 0.5f );

typedef QuatTS_tpl QuatTS;

always 64 bit

typedef QuatTS_tpl QuatTSd;

always 64 bit

typedef QuatTS_tpl QuatTSr;

variable float precision. depending on the target system it can be between 32, 64 or 80 bit

template <class F1,class F2> QuatT_tpl operator *(const QuatT_tpl & q, const QuatT_tpl & p);

!

• Implements the multiplication operator: QuatT=QuatposA*QuatposB

*

• AxB = operation B followed by operation A.
• A multiplication takes 31 muls and 30 adds (=61 float operations).

*

• Example:
• QuatT quatposA = QuatT::CreateRotationX(1.94192f,Vec3(77,55,44));
• QuatT quatposB = QuatT::CreateRotationZ(3.14192f,Vec3(11,22,33));
• QuatT qp = quatposA*quatposB;

template <class F1,class F2> QuatT_tpl operator *(const QuatT_tpl & p, const Quat_tpl & q);

! *

• Implements the multiplication operator: QuatT=Quatpos*Quat

*

• AxB = operation B followed by operation A.
• A multiplication takes 16 muls and 12 adds (=28 float operations).

*

• Example:
• Quat quat = Quat::CreateRotationX(1.94192f);;
• QuatT quatpos = QuatT::CreateRotationZ(3.14192f,Vec3(11,22,33));
• QuatT qp = quatpos*quat;

template <class F,class F2> Vec3_tpl operator *(const QuatT_tpl & q, const Vec3_tpl & v);

!

• post-multiply of a QuatT and a Vec3 (3D rotations with quaternions)

*

• Example:
• Quat q(1,0,0,0);
• Vec3 v(33,44,55);
• Vec3 result = q*v;

static QuatT_tpl CreateFromVectors(const Vec3_tpl& vx, const Vec3_tpl& vy, const Vec3_tpl& vz, const Vec3_tpl& pos);

static QuatT_tpl CreateNLerp(const QuatT_tpl & p, const QuatT_tpl & q, F t);

static QuatT_tpl CreateRotationAA(F cosha, F sinha, const Vec3_tpl axis, const Vec3_tpl& trans = Vec3(ZERO));

static QuatT_tpl CreateRotationXYZ(const Ang3_tpl& rad, const Vec3_tpl& trans = Vec3(ZERO));

DEFINE_ALIGNED_DATA(QuatTd, QuatTrA, 16);

typedef __declspec(align(16)) Quat_tpl

Vec3_tpl GetColumn0() const;

Vec3_tpl GetColumn1() const;

Vec3_tpl GetColumn2() const;

Vec3_tpl GetColumn3() const;

QuatT_tpl GetInverted() const;

DEFINE_ALIGNED_DATA(QuatT, QuatTA, 32);

wastest 4byte per quatT // typedef __declspec(align(16)) Quat_tpl

Vec3_tpl GetRow0() const;

Vec3_tpl GetRow1() const;

Vec3_tpl GetRow2() const;

QuatT_tpl GetScaled(F scale);

Quat_tpl q;

this is the quaternion

void Invert();

static bool IsEquivalent(const QuatT_tpl& qt1, const QuatT_tpl& qt2, F qe = RAD_EPSILON, F ve = VEC_EPSILON);

bool IsIdentity() const;

bool IsValid() const;

QuatT_tpl();

QuatT_tpl(const DualQuat_tpl& qd);

convert unit DualQuat back to QuatT

Vec3_tpl t;

this is the translation vector and a scalar (for uniform scaling?)

explicit QuatT_tpl(const Matrix34_tpl& m);

explicit QuatT_tpl(const QuatTS_tpl& qts);

template <typename F1> QuatT_tpl(const QuatT_tpl& qt);

CONSTRUCTOR: implement the copy/casting/assignment constructor:

QuatT_tpl(const Quat_tpl& quat, const Vec3_tpl& trans);

QuatT_tpl(const Vec3_tpl& _t, const Quat_tpl& _q);

QuatT_tpl(type_identity);

QuatT_tpl(type_zero);

initialize with zeros

void SetFromVectors(const Vec3& vx, const Vec3& vy, const Vec3& vz, const Vec3& pos);

all vectors are stored in columns

void SetIdentity();

void SetNLerp(const QuatT_tpl & p, const QuatT_tpl & tq, F ti);

!

• linear-interpolation between quaternions (lerp)

*

• Example:
• CQuaternion result,p,q;
• result=qlerp( p, q, 0.5f );

void SetRotationAA(F cosha, F sinha, const Vec3_tpl axis, const Vec3_tpl& trans = Vec3(ZERO));

void SetRotationXYZ(const Ang3_tpl& rad, const Vec3_tpl& trans = Vec3(ZERO));

!

• Convert three Euler angle to mat33 (rotation order:XYZ)
• The Euler angles are assumed to be in radians.
• The translation-vector is set to zero by default.

*

• Example 1:
• QuatT qp;
• qp.SetRotationXYZ( Ang3(0.5f,0.2f,0.9f), translation );

*

• Example 2:
• QuatT qp=QuatT::CreateRotationXYZ( Ang3(0.5f,0.2f,0.9f), translation );

void SetTranslation(const Vec3_tpl& trans);

typedef QuatT_tpl QuatT;

always 32 bit

typedef QuatT_tpl QuatTd;

always 64 bit

typedef QuatT_tpl QuatTr;

variable float precision. depending on the target system it can be between 32, 64 or bit

Vec3_tpl v;

F w;

Quat_tpl operator -() const;

flip quaternion. don't confuse this with quaternion-inversion.

template <class F1,class F2> Quat_tpl operator -(const Quat_tpl & q, const Quat_tpl & p);

!

• subtraction operator

*

• Example:
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat result=p-q;

*

• Example: (self-subtraction operator)
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat p-=q;

Quat_tpl operator !() const;

!

• invert quaternion.

*

• Example 1:
• Quat q=Quat::CreateRotationXYZ(Ang3(1,2,3));
• Quat result = !q;
• Quat result = GetInverted(q);
• q.Invert();

bool operator !=(const Quat_tpl & q) const;

template <class F1,class F2> Quat_tpl operator %(const Quat_tpl & q, const Quat_tpl & tp);

template <class F1,class F2> void operator %=(Quat_tpl & q, const Quat_tpl & tp);

template <typename F> Quat_tpl operator *(F t, const Quat_tpl & q);

! Scale quaternion free function.

template <typename F1,typename F2> Quat_tpl operator *(const Quat_tpl & q, F2 t);

template <class F1,class F2> QuatT_tpl operator *(const Quat_tpl & q, const QuatT_tpl & p);

!

• Implements the multiplication operator: QuatT=Quat*Quatpos

*

• AxB = operation B followed by operation A.
• A multiplication takes 31 muls and 27 adds (=58 float operations).

*

• Example:
• Quat quat = Quat::CreateRotationX(1.94192f);;
• QuatT quatpos = QuatT::CreateRotationZ(3.14192f,Vec3(11,22,33));
• QuatT qp = quat*quatpos;

DEFINE_ALIGNED_DATA(Quat, QuatA, 16);

typedef __declspec(align(16)) Quat_tpl

template <class F1,class F2> Quat_tpl operator *(const Quat_tpl & q, const Quat_tpl & p);

! *

• Implements the multiplication operator: Qua=QuatA*QuatB

*

• AxB = operation B followed by operation A.
• A multiplication takes 16 muls and 12 adds.

*

• Example 1:
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat result=p*q;

*

• Example 2: (self-multiplication)
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat p*=q;

template <class F,class F2> Vec3_tpl operator *(const Quat_tpl & q, const Vec3_tpl & v);

! *

• post-multiply of a quaternion and a Vec3 (3D rotations with quaternions)

*

• Example:
• Quat q(1,0,0,0);
• Vec3 v(33,44,55);
• Vec3 result = q*v;

template <class F,class F2> Vec3_tpl operator *(const Vec3_tpl & v, const Quat_tpl & q);

!

• pre-multiply of a quaternion and a Vec3 (3D rotations with quaternions)

*

• Example:
• Quat q(1,0,0,0);
• Vec3 v(33,44,55);
• Vec3 result = v*q;

void operator *=(F op);

multiplication by a scalar

Vec3_tpl GetColumn(uint32 i);

A quaternion is a compressed matrix. Thus there is no problem extracting the rows & columns.

template <class F1,class F2> void operator *=(Quat_tpl & q, const Quat_tpl & p);

template <typename F1,typename F2> Quat_tpl operator /(const Quat_tpl & q, F2 t);

template <class F1,class F2> Quat_tpl operator /(const Quat_tpl & q, const Quat_tpl & p);

!

• division operator

*

• Example 1:
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat result=p/q;

*

• Example 2: (self-division)
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat p/=q;

template <class F1,class F2> void operator /=(Quat_tpl & q, const Quat_tpl & p);

template <typename F1,typename F2> F1 operator |(const Quat_tpl& q, const Quat_tpl& p);

! *

• The "inner product" or "dot product" operation.

*

• calculate the "inner product" between two Quaternion.
• If both Quaternion are unit-quaternions, the result is the cosine: p*q=cos(angle)

*

• Example:
• Quat p(1,0,0,0),q(1,0,0,0);
• f32 cosine = ( p | q );

template <class F1,class F2> Quat_tpl operator +(const Quat_tpl & q, const Quat_tpl & p);

!

• addition operator

*

• Example:
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat result=p+q;

*

• Example:(self-addition operator)
• Quat p(1,0,0,0),q(1,0,0,0);
• Quat p-=q;

template <class F1,class F2> void operator +=(Quat_tpl & q, const Quat_tpl & p);

Quat_tpl& operator =(const Quat_tpl & src);

ASSIGNMENT OPERATOR of identical Quat types. The assignment operator has precedence over assignment constructor Quat q; q=q0;

template <class F1,class F2> void operator -=(Quat_tpl & q, const Quat_tpl & p);

bool operator ==(const Quat_tpl & q) const;

Exact compare of 2 quats.

static Quat_tpl CreateExpSlerp(const Quat_tpl & p, const Quat_tpl & q, F t);

static Quat_tpl CreateIdentity();

static Quat_tpl CreateNlerp(const Quat_tpl & p, const Quat_tpl & tq, F t);

static Quat_tpl CreateNlerpCubic(const Quat_tpl & p, const Quat_tpl & tq, F t);

static Quat_tpl CreateRotationAA(F cosha, F sinha, const Vec3_tpl & axis);

static Quat_tpl CreateRotationAA(F rad, const Vec3_tpl & axis);

static Quat_tpl CreateRotationV0V1(const Vec3_tpl& v0, const Vec3_tpl& v1);

static Quat_tpl CreateRotationVDir(const Vec3_tpl& vdir);

static Quat_tpl CreateRotationVDir(const Vec3_tpl& vdir, F roll);

static Quat_tpl CreateRotationX(f32 r);

static Quat_tpl CreateRotationXYZ(const Ang3_tpl & a);

static Quat_tpl CreateRotationY(f32 r);

static Quat_tpl CreateRotationZ(f32 r);

static Quat_tpl CreateSlerp(const Quat_tpl & p, const Quat_tpl & tq, F t);

static Quat_tpl CreateSquad(const Quat_tpl& p, const Quat_tpl& a, const Quat_tpl& b, const Quat_tpl& q, F t);

DEFINE_ALIGNED_DATA(Quatd, QuatrA, 32);

typedef __declspec(align(16)) Quat_tpl

static Quat_tpl exp(const Vec3_tpl& v);

Exponent of Quaternion.

Vec3_tpl GetColumn0() const;

Vec3_tpl GetColumn1() const;

Vec3_tpl GetColumn2() const;

F GetFwdX() const;

These are just copy & pasted components of the GetColumn1() above.

F GetFwdY() const;

F GetFwdZ() const;

Quat_tpl GetInverted() const;

F GetLength() const;

!

• get length of quaternion.

*

• Example 1:
• f32 l=q.GetLength();

Quat_tpl GetNormalized() const;

Quat_tpl GetNormalizedFast() const;

Quat_tpl GetNormalizedSafe() const;

F GetRotZ() const;

Vec3_tpl GetRow0() const;

Vec3_tpl GetRow1() const;

Vec3_tpl GetRow2() const;

Quat_tpl GetScaled(F scale) const;

useless, please delete

void Invert();

static bool IsEquivalent(const Quat_tpl& q1, const Quat_tpl& q2, F qe = RAD_EPSILON);

bool IsIdentity() const;

Check if identity quaternion.

bool IsUnit(F e = VEC_EPSILON) const;

bool IsValid(F e = VEC_EPSILON) const;

static Quat_tpl LnDif(const Quat_tpl& q1, const Quat_tpl& q2);

! Logarithm of Quaternion difference.

static Vec3_tpl log(const Quat_tpl& q);

logarithm of a quaternion, imaginary part (the real part of the logarithm is always 0)

void Normalize();

!

• normalize quaternion.

*

• Example 1:
• Quat q; q.Normalize();

*

• Example 2:
• Quat q=Quat(1,2,3,4);
• Quat qn=q.GetNormalized();

void NormalizeFast();

void NormalizeSafe();

Quat_tpl();

template <class F1>  explicit Quat_tpl(const Ang3_tpl& ang);

CONSTRUCTOR for different types. It converts a Euler Angle into a Quat and converts between double/float. . Needs to be 'explicit' because we loose fp-precision in the conversion process Quat(Ang3r(1,2,3));

explicit Quat_tpl(const Ang3_tpl& ang);

CONSTRUCTOR for different types. It converts a Euler Angle into a Quat. Needs to be 'explicit' because we loose fp-precision in the conversion process Quat(Ang3(1,2,3));

Quat_tpl(F qw, F qx, F qy, F qz);

CONSTRUCTOR to initialize a Quat from 4 floats Quat q(1,0,0,0);

Quat_tpl(F scalar, const Vec3_tpl & vector);

CONSTRUCTOR to initialize a Quat with a scalar and a vector Quat q(1,Vec3(0,0,0));

template <class F1>  explicit Quat_tpl(const Matrix33_tpl& m);

CONSTRUCTOR for different types. It converts a Matrix33 into a Quat and converts between double/float. Needs to be 'explicit' because we loose fp-precision the conversion process Quat(m33r); Quatr(m33);

explicit Quat_tpl(const Matrix33_tpl& m);

CONSTRUCTOR for different types. It converts a Matrix33 into a Quat. Needs to be 'explicit' because we loose fp-precision in the conversion process Quat(m33);

template <class F1>  explicit Quat_tpl(const Matrix34_tpl& m);

CONSTRUCTOR for different types. It converts a Matrix34 into a Quat and converts between double/float. Needs to be 'explicit' because we loose fp-precision the conversion process Quat(m34r); Quatr(m34);

explicit Quat_tpl(const Matrix34_tpl& m);

CONSTRUCTOR for different types. It converts a Matrix34 into a Quat. Needs to be 'explicit' because we loose fp-precision in the conversion process Quat(m34);

template <class F1> Quat_tpl(const Quat_tpl& q);

CONSTRUCTOR for identical types which converts between double/float Quat q32=q64; Quatr q64=q32;

Quat_tpl(const Quat_tpl& q);

CONSTRUCTOR for identical types Quat q=q0;

Quat_tpl(type_identity);

Quat_tpl(type_zero);

initialize with zeros

void SetExpSlerp(const Quat_tpl & p, const Quat_tpl & tq, F t);

!

• spherical-interpolation between quaternions (algebraic slerp_a)
• I have included this function just for the sake of completeness, because
• its the only useful application to check if exp & log really work.
• Both slerp-functions are returning the same result.

*

• Example:
• Quat result,p,q;
• result.SetExpSlerp( p,q,0.3345f );

void SetIdentity();

!

• set identity quaternion

*

• Example:
• Quat q=Quat::CreateIdentity();
• or
• q.SetIdentity();
• or
• Quat p=Quat(IDENTITY);

void SetNlerp(const Quat_tpl & p, const Quat_tpl & tq, F t);

!

• linear-interpolation between quaternions (lerp)

*

• Example:
• CQuaternion result,p,q;
• result=qlerp( p, q, 0.5f );

void SetNlerpCubic(const Quat_tpl & p, const Quat_tpl & tq, F t);

!

• linear-interpolation between quaternions (nlerp)
• in this case we convert the t-value into a 1d cubic spline to get closer to Slerp

*

• Example:
• Quat result,p,q;
• result.SetNlerpCubic( p, q, 0.5f );

void SetRotationAA(F cosha, F sinha, const Vec3_tpl & axis);

void SetRotationAA(F rad, const Vec3_tpl & axis);

void SetRotationV0V1(const Vec3_tpl& v0, const Vec3_tpl& v1);

! *

• Create rotation-quaternion that rotates from one vector to another.
• Both vectors are assumed to be normalized.

*

• Example:
• Quat q=Quat::CreateRotationV0V1( v0,v1 );
• q.SetRotationV0V1( v0,v1 );

void SetRotationVDir(const Vec3_tpl& vdir);

! *

• param vdir normalized view direction.
• param roll radiant to rotate about Y-axis.

*

• Given a view-direction and a radiant to rotate about Y-axis, this function builds a 3x3 look-at quaternion
• using only simple vector arithmetic. This function is always using the implicit up-vector Vec3(0,0,1).
• The view-direction is always stored in column(1).
• IMPORTANT: The view-vector is assumed to be normalized, because all trig-values for the orientation are being
• extracted directly out of the vector. This function must NOT be called with a view-direction
• that is close to Vec3(0,0,1) or Vec3(0,0,-1). If one of these rules is broken, the function returns a quaternion
• with an undefined rotation about the Z-axis.

*

• Rotation order for the look-at-quaternion is Z-X-Y. (Zaxis=YAW / Xaxis=PITCH / Yaxis=ROLL)

*

• COORDINATE-SYSTEM

*

• z-axis
• ^
• |
• | y-axis
• | /
• | /
• |/
• +---------------> x-axis

*

• Example:
• Quat LookAtQuat=Quat::CreateRotationVDir( Vec3(0,1,0) );
• or
• Quat LookAtQuat=Quat::CreateRotationVDir( Vec3(0,1,0), 0.333f );

void SetRotationVDir(const Vec3_tpl& vdir, F r);

void SetRotationX(f32 r);

!

• Create rotation-quaternion that about the x-axis.

*

• Example:
• Quat q=Quat::CreateRotationX( radiant );
• or
• q.SetRotationX( Ang3(1,2,3) );

void SetRotationXYZ(const Ang3_tpl & a);

!

• Create rotation-quaternion that around the fixed coordinate axes.

*

• Example:
• Quat q=Quat::CreateRotationXYZ( Ang3(1,2,3) );
• or
• q.SetRotationXYZ( Ang3(1,2,3) );

void SetRotationY(f32 r);

!

• Create rotation-quaternion that about the y-axis.

*

• Example:
• Quat q=Quat::CreateRotationY( radiant );
• or
• q.SetRotationY( radiant );

void SetRotationZ(f32 r);

!

• Create rotation-quaternion that about the z-axis.

*

• Example:
• Quat q=Quat::CreateRotationZ( radiant );
• or
• q.SetRotationZ( radiant );

void SetSlerp(const Quat_tpl & tp, const Quat_tpl & tq, F t);

!

• spherical-interpolation between quaternions (geometrical slerp)

*

• Example:
• Quat result,p,q;
• result.SetSlerp( p, q, 0.5f );

void SetSquad(const Quat_tpl& p, const Quat_tpl& a, const Quat_tpl& b, const Quat_tpl& q, F t);

! squad(p,a,b,q,t) = slerp( slerp(p,q,t),slerp(a,b,t), 2(1-t)t).

typedef Quat_tpl CryQuat;

typedef Quat_tpl Quat;

always 32 bit

typedef Quat_tpl Quatd;

always 64 bit

typedef Quat_tpl quaternion;

typedef Quat_tpl quaternionf;

typedef Quat_tpl Quatr;

variable float precision. depending on the target system it can be between 32, 64 or 80 bit