xsi_quaternionf.h

Go to the documentation of this file.

//*****************************************************************************
//*****************************************************************************
#ifndef __XSIQUATERNIONF_H__
#define __XSIQUATERNIONF_H__

#include "sicppsdk.h"
#include "xsi_vector4f.h"
#include "xsi_vector3f.h"

namespace XSI {

namespace MATH {

class CRotation3f;

//*****************************************************************************
//*****************************************************************************
class SICPPSDKDECL CQuaternionf
{
public:
        SICPPSDK_INLINE CQuaternionf();

        SICPPSDK_INLINE CQuaternionf( const CQuaternionf& in_quaternion );

        ~CQuaternionf() {};

        SICPPSDK_INLINE CQuaternionf & operator=( const CQuaternionf & in_quaternion);

        SICPPSDK_INLINE CQuaternionf( const float in_W, const float in_X, const float in_Y, const float in_Z );

        SICPPSDK_INLINE CQuaternionf( const CVector3f& in_vct );

        SICPPSDK_INLINE CQuaternionf( const CVector4f& in_vct );

        SICPPSDK_INLINE bool Equals( const CQuaternionf &in_Quat ) const;

        SICPPSDK_INLINE bool EpsilonEquals( const CQuaternionf& in_quat, const float in_fEpsilon ) const;

        SICPPSDK_INLINE bool operator == ( const CQuaternionf &in_Quat ) const;

        SICPPSDK_INLINE bool operator < ( const CQuaternionf& in_Quat ) const;

        SICPPSDK_INLINE CQuaternionf& operator *= ( const CQuaternionf &in_Quat );

        SICPPSDK_INLINE CQuaternionf& Mul( const CQuaternionf &in_Quat );

        SICPPSDK_INLINE CQuaternionf& Mul( const CQuaternionf &in_Quat1, const CQuaternionf &in_Quat2);

        SICPPSDK_INLINE float Dot( const CQuaternionf& in_quat1 ) const;

        SICPPSDK_INLINE CQuaternionf& Slerp( const CQuaternionf& in_quatStart, const CQuaternionf& in_quatEnd, const float in_fU );

        SICPPSDK_INLINE CQuaternionf& operator -= ( const CQuaternionf &in_Quat );

        SICPPSDK_INLINE CQuaternionf& SubInPlace( const CQuaternionf &in_Quat );

        SICPPSDK_INLINE CQuaternionf& Sub( const CQuaternionf &in_Quat1,  const CQuaternionf &in_Quat2);

        SICPPSDK_INLINE CQuaternionf& NegateInPlace();

        SICPPSDK_INLINE CQuaternionf& Negate( const CQuaternionf &in_Quat);

        SICPPSDK_INLINE float GetSquaredLength() const;

        SICPPSDK_INLINE float GetLength() const;

        SICPPSDK_INLINE CQuaternionf& operator += ( const CQuaternionf &in_Quat);

        SICPPSDK_INLINE CQuaternionf& AddInPlace( const CQuaternionf &in_Quat );

        SICPPSDK_INLINE CQuaternionf& Add( const CQuaternionf &in_Quat1,  const CQuaternionf &in_Quat2);

        SICPPSDK_INLINE CQuaternionf& ConjugateInPlace();

        SICPPSDK_INLINE CQuaternionf& Conjugate( const CQuaternionf &in_Quat);

        SICPPSDK_INLINE CQuaternionf& InvertInPlace();

        SICPPSDK_INLINE CQuaternionf& Invert( const CQuaternionf &in_Quat);

        SICPPSDK_INLINE CQuaternionf& SetIdentity();

        SICPPSDK_INLINE CQuaternionf& Copy( const CQuaternionf &in_Quat );

        SICPPSDK_INLINE CQuaternionf& NormalizeInPlace();

        SICPPSDK_INLINE void Get( float &out_W, float &out_X, float &out_Y, float &out_Z ) const;

        SICPPSDK_INLINE CVector3f GetVector3() const;

        SICPPSDK_INLINE CVector4f GetVector4() const;

        SICPPSDK_INLINE void Get( CVector4f &io_XYZWVector ) const;

        SICPPSDK_INLINE CQuaternionf& Set( float in_W,  float in_X,  float in_Y,  float in_Z);

        SICPPSDK_INLINE CQuaternionf& Set( const CVector3f &in_XYZVector );

        SICPPSDK_INLINE CQuaternionf& Set( const CVector4f &in_XYZWVector );

        SICPPSDK_INLINE float GetValue( short in_nIndex ) const;

        SICPPSDK_INLINE CQuaternionf& SetValue( short in_nIndex, float newVal);

        SICPPSDK_INLINE float GetW() const;

        SICPPSDK_INLINE CQuaternionf& PutW( float newVal);

        SICPPSDK_INLINE float GetZ() const;

        SICPPSDK_INLINE CQuaternionf& PutZ( float newVal);

        SICPPSDK_INLINE float GetY() const;

        SICPPSDK_INLINE CQuaternionf& PutY( float newVal);

        SICPPSDK_INLINE float GetX() const;

        SICPPSDK_INLINE CQuaternionf& PutX( float newVal);

        SICPPSDK_INLINE bool operator !=(const CQuaternionf & in_quat ) const;

private:
        float m_W, m_X, m_Y, m_Z;
};

//inline functions
SICPPSDK_INLINE CQuaternionf::CQuaternionf()
{
        SetIdentity();
}

SICPPSDK_INLINE CQuaternionf::CQuaternionf( const CQuaternionf& in_quaternion)
{
        *this = in_quaternion;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::operator=( const CQuaternionf & in_Quat )
{
        m_W = in_Quat.m_W;
        m_X = in_Quat.m_X;
        m_Y = in_Quat.m_Y;
        m_Z = in_Quat.m_Z;

        return *this;
}

SICPPSDK_INLINE CQuaternionf::CQuaternionf( const float in_W, const float in_X, const float in_Y, const float in_Z )
{
        Set( in_W, in_X, in_Y, in_Z );
}

SICPPSDK_INLINE CQuaternionf::CQuaternionf( const XSI::MATH::CVector3f& in_vct )
{
        Set( in_vct );
}

SICPPSDK_INLINE CQuaternionf::CQuaternionf( const XSI::MATH::CVector4f& in_vct )
{
        Set( in_vct );
}

SICPPSDK_INLINE bool CQuaternionf::Equals( const CQuaternionf &in_Quat ) const
{
        return (this == &in_Quat) ? true :
                (m_W == in_Quat.m_W &&
                m_X == in_Quat.m_X &&
                m_Y == in_Quat.m_Y &&
                m_Z == in_Quat.m_Z );
}

SICPPSDK_INLINE bool CQuaternionf::operator == ( const CQuaternionf &in_Quat ) const
{
        return Equals(in_Quat);
}

SICPPSDK_INLINE bool CQuaternionf::operator < ( const CQuaternionf& in_Quat) const
{
        if ( m_W != in_Quat.m_W ) return m_W < in_Quat.m_W;
        if ( m_Z != in_Quat.m_Z ) return m_Z < in_Quat.m_Z;
        if ( m_Y != in_Quat.m_Y ) return m_Y < in_Quat.m_Y;
        if ( m_X != in_Quat.m_X ) return m_X < in_Quat.m_X;
        return false;
}

SICPPSDK_INLINE bool CQuaternionf::operator != ( const CQuaternionf &in_Quat ) const
{
        return ! Equals( in_Quat );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::operator *= ( const CQuaternionf &in_Quat )
{

        return Mul(*this, in_Quat);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Mul( const CQuaternionf &in_Quat )
{
        return Mul(*this, in_Quat);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Mul
(
        const CQuaternionf &in_Quat1,
        const CQuaternionf &in_Quat2
)
{
        float dW, dX, dY, dZ;

        dW = in_Quat1.m_W * in_Quat2.m_W - in_Quat1.m_X * in_Quat2.m_X -
                in_Quat1.m_Y * in_Quat2.m_Y - in_Quat1.m_Z * in_Quat2.m_Z ;

        dX = in_Quat1.m_W * in_Quat2.m_X + in_Quat2.m_W * in_Quat1.m_X +
                in_Quat1.m_Y * in_Quat2.m_Z - in_Quat2.m_Y * in_Quat1.m_Z ;

        dY = in_Quat1.m_W * in_Quat2.m_Y + in_Quat2.m_W * in_Quat1.m_Y -
                in_Quat1.m_X * in_Quat2.m_Z + in_Quat2.m_X * in_Quat1.m_Z ;

        dZ = in_Quat1.m_W * in_Quat2.m_Z + in_Quat2.m_W * in_Quat1.m_Z +
                in_Quat1.m_X * in_Quat2.m_Y - in_Quat2.m_X * in_Quat1.m_Y ;

        m_W = dW; m_X = dX; m_Y = dY; m_Z = dZ;

        return *this;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::operator -= ( const CQuaternionf &in_Quat )
{
        return Sub(*this, in_Quat );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::SubInPlace( const CQuaternionf &in_Quat )
{
        return Sub(*this, in_Quat );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Sub
(
        const CQuaternionf &in_Quat1,
        const CQuaternionf &in_Quat2
)
{
        m_W = in_Quat1.m_W - in_Quat2.m_W;
        m_X = in_Quat1.m_X - in_Quat2.m_X;
        m_Y = in_Quat1.m_Y - in_Quat2.m_Y;
        m_Z = in_Quat1.m_Z - in_Quat2.m_Z;

        return *this;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::NegateInPlace()
{
   return Negate(*this);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Negate( const CQuaternionf &in_Quat)
{
   m_W = -(in_Quat.m_W);
   m_X = -(in_Quat.m_X);
   m_Y = -(in_Quat.m_Y);
   m_Z = -(in_Quat.m_Z);

   return( *this );
}

SICPPSDK_INLINE float CQuaternionf::GetSquaredLength() const
{
        return( m_W * m_W + m_X * m_X + m_Y * m_Y + m_Z * m_Z );
}

SICPPSDK_INLINE float CQuaternionf::GetLength() const
{
        return( sqrt( GetSquaredLength() ) );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::operator += ( const CQuaternionf &in_Quat)
{
        return Add( *this,  in_Quat );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::AddInPlace( const CQuaternionf &in_Quat )
{
        return Add( *this,  in_Quat );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Add
(
        const CQuaternionf &in_Quat1,
        const CQuaternionf &in_Quat2
)
{
        m_W = in_Quat1.m_W + in_Quat2.m_W;
        m_X = in_Quat1.m_X + in_Quat2.m_X;
        m_Y = in_Quat1.m_Y + in_Quat2.m_Y;
        m_Z = in_Quat1.m_Z + in_Quat2.m_Z;
        return *this;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::ConjugateInPlace()
{
        return Conjugate(*this);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Conjugate( const CQuaternionf &in_Quat)
{
        m_W = in_Quat.m_W;
        m_X = -in_Quat.m_X;
        m_Y = -in_Quat.m_Y;
        m_Z = -in_Quat.m_Z;

        return( *this );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::InvertInPlace()
{
        return Invert(*this);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Invert( const CQuaternionf &in_Quat)
{
        return Conjugate(in_Quat);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::SetIdentity()
{
        m_W = 1.0;
        m_X = m_Y = m_Z = 0.0;

        return( *this );
}

SICPPSDK_INLINE CQuaternionf&  CQuaternionf::Copy( const CQuaternionf &in_Quat )
{
        return *this = in_Quat;
}

SICPPSDK_INLINE CVector3f CQuaternionf::GetVector3( ) const
{
        return CVector3f( m_X, m_Y, m_Z);
}

SICPPSDK_INLINE CVector4f CQuaternionf::GetVector4( ) const
{
        return CVector4f( m_X, m_Y, m_Z, m_W);
}

SICPPSDK_INLINE void CQuaternionf::Get
(
        float &io_W,
        float &io_X,
        float &io_Y,
        float &io_Z
) const
{
        io_W = m_W;
        io_X = m_X;
        io_Y = m_Y;
        io_Z = m_Z;
}

SICPPSDK_INLINE void CQuaternionf::Get( CVector4f &io_XYZWVector ) const
{
        io_XYZWVector.Set( m_X, m_Y, m_Z, m_W);
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Set
(
        float in_W,
        float in_X,
        float in_Y,
        float in_Z
)
{
        m_W = in_W;
        m_X = in_X;
        m_Y = in_Y;
        m_Z = in_Z;

        return *this;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Set( const CVector3f &in_XYZVector )
{
        m_W = 1.0;
        m_X = in_XYZVector.GetX();
        m_Y = in_XYZVector.GetY();
        m_Z = in_XYZVector.GetZ();

        return *this;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Set( const CVector4f &in_XYZWVector )
{
        m_W = in_XYZWVector.GetW();
        m_X = in_XYZWVector.GetX();
        m_Y = in_XYZWVector.GetY();
        m_Z = in_XYZWVector.GetZ();

        return *this;
}

SICPPSDK_INLINE float CQuaternionf::GetValue( short in_nIndex ) const
{
        assert(in_nIndex >= 0 && in_nIndex < 4);

        switch (in_nIndex)
        {
                case 0: return m_W;
                case 1: return m_X;
                case 2: return m_Y;
                case 3: return m_Z;
        }

        return 0.0; // invalid index, return 0.0
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::SetValue( short in_nIndex,  float newVal)
{
        assert(in_nIndex >= 0 && in_nIndex < 4);

        switch (in_nIndex)
        {
                case 0:  m_W = newVal; break;
                case 1:  m_X = newVal; break;
                case 2:  m_Y = newVal; break;
                case 3:  m_Z = newVal; break;
                // note: do nothing when invalid index is provided
        }

        return *this;
}

SICPPSDK_INLINE float CQuaternionf::GetW() const
{
        return m_W;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::PutW( float newVal)
{
        m_W = newVal;

        return *this;
}

SICPPSDK_INLINE float CQuaternionf::GetZ() const
{
        return m_Z;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::PutZ( float newVal)
{
        m_Z = newVal;
        return *this;
}

SICPPSDK_INLINE float CQuaternionf::GetY() const
{
        return m_Y;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::PutY( float newVal)
{
        m_Y = newVal;
        return *this;
}


SICPPSDK_INLINE float CQuaternionf::GetX() const
{
        return m_X;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::PutX( float newVal)
{
        m_X = newVal;
        return *this;
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::NormalizeInPlace()
{
   float rLen = GetSquaredLength();

   if( fabs( rLen - 1.0f ) >= PicoEPS )
   {
      if( rLen < PicoEPS )
      {
         m_X = m_Y = m_Z = 0.0;
         m_W = 1.0;
      }
      else
      {
         rLen = 1.0f / sqrt( rLen );
         m_W *= rLen;
         m_X *= rLen;
         m_Y *= rLen;
         m_Z *= rLen;

                 LimitValue( m_W, -1.0, 1.0 );
      }
   }
   else
   {
                LimitValue( m_W, -1.0, 1.0 );
   }

   return( *this );
}

SICPPSDK_INLINE CQuaternionf& CQuaternionf::Slerp
(
        const CQuaternionf& in_quatStart,
        const CQuaternionf& in_quatEnd,
        const float                     in_fU
)
{
   float fDot, fScale1, fScale2;
   bool bNegate = false;

   fDot = in_quatStart.Dot( in_quatEnd );
   if ( fDot < 0.0 )
   {
      fDot = -fDot;
      bNegate = true;
   }

   if( fDot >= ( 1.0f - MicroEPS ) )
   {
      fScale1 = 1.0f - in_fU;
      fScale2 = in_fU;
   }
   else
   {
      float fAngle, fFactor;

      LimitValue( fDot, -1.0, 1.0 );
      fAngle = acos( fDot );
      fFactor = 1.0f / sin( fAngle );

      fScale1 = sin( (1.0f - in_fU) * fAngle ) * fFactor;
      fScale2 = sin( in_fU * fAngle ) * fFactor;
   }

   if( bNegate == true )
      fScale2 = -fScale2;

   m_W = fScale1 * in_quatStart.m_W + fScale2 * in_quatEnd.m_W;
   m_X = fScale1 * in_quatStart.m_X + fScale2 * in_quatEnd.m_X;
   m_Y = fScale1 * in_quatStart.m_Y + fScale2 * in_quatEnd.m_Y;
   m_Z = fScale1 * in_quatStart.m_Z + fScale2 * in_quatEnd.m_Z;

   return( *this );
}

SICPPSDK_INLINE float CQuaternionf::Dot( const CQuaternionf& in_quat ) const
{
   return( GetW() * in_quat.GetW() +
           GetX() * in_quat.GetX() +
           GetY() * in_quat.GetY() +
           GetZ() * in_quat.GetZ() );
}

SICPPSDK_INLINE bool CQuaternionf::EpsilonEquals( const CQuaternionf& in_quat, const float in_fEpsilon ) const
{
   return( fabs( GetW() - in_quat.GetW() ) < in_fEpsilon &&
           fabs( GetX() - in_quat.GetX() ) < in_fEpsilon &&
           fabs( GetY() - in_quat.GetY() ) < in_fEpsilon &&
           fabs( GetZ() - in_quat.GetZ() ) < in_fEpsilon );
}

};
};

#endif // __XSIQUATERNIONF_H__