xsi_quaternion.h

Go to the documentation of this file.

//*****************************************************************************
//*****************************************************************************
#ifndef __XSIQUATERNION_H__
#define __XSIQUATERNION_H__

#include "sicppsdk.h"
#include "xsi_rotation.h"
#include "xsi_vector3.h"
#include "xsi_vector4.h"

namespace XSI {

namespace MATH {

class CVector3;
class CVector4;

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

        SICPPSDK_INLINE CQuaternion( const CQuaternion& in_quaternion);

        ~CQuaternion() {};

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

        SICPPSDK_INLINE CQuaternion( const double in_dW, const double in_dX,
               const double in_dY, const double in_dZ );

        SICPPSDK_INLINE CQuaternion( const CVector3& in_vct );

        SICPPSDK_INLINE CQuaternion( const CVector4& in_vct );

        SICPPSDK_INLINE CQuaternion( const CRotation& in_Rot );

        CQuaternion& operator = ( const CRotation &in_Rot );

        CQuaternion& SetFromRotation( const CRotation &in_Rot );

        CRotation GetRotation() const;

        CQuaternion& Normalize();

        bool EpsilonEquals( const CQuaternion &in_Quat, double in_dEpsilon ) const;

        SICPPSDK_INLINE bool Equals( const CQuaternion &in_Quat ) const;

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

        CQuaternion& Slerp( const CQuaternion &in_Quat1, const CQuaternion &in_Quat2, double in_dU);

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

        SICPPSDK_INLINE CQuaternion& MulInPlace( const CQuaternion &in_Quat );

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

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

        SICPPSDK_INLINE CQuaternion& SubInPlace( const CQuaternion &in_Quat );

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

        SICPPSDK_INLINE CQuaternion& NegateInPlace();

        SICPPSDK_INLINE CQuaternion& Negate( const CQuaternion &in_Quat);

        double GetLengthSquared() const;

        double GetLength() const;

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

        SICPPSDK_INLINE CQuaternion& AddInPlace( const CQuaternion &in_Quat );

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

        SICPPSDK_INLINE CQuaternion& ConjugateInPlace();

        SICPPSDK_INLINE CQuaternion& Conjugate( const CQuaternion &in_Quat);

        SICPPSDK_INLINE CQuaternion& InvertInPlace();

        SICPPSDK_INLINE CQuaternion& Invert( const CQuaternion &in_Quat);

        SICPPSDK_INLINE CQuaternion& SetIdentity();

        SICPPSDK_INLINE CQuaternion&  Copy( const CQuaternion &in_Quat );

        SICPPSDK_INLINE void Get( double &out_dW, double &out_dX, double &out_dY, double &out_dZ ) const;

        CVector3 Get() const;

        SICPPSDK_INLINE void Get( CVector4 &io_XYZWVector ) const;

        SICPPSDK_INLINE CQuaternion& Set( double in_dW,  double in_dX,  double in_dY,  double in_dZ);

        SICPPSDK_INLINE CQuaternion& Set( const CVector3 &in_XYZVector );

        SICPPSDK_INLINE CQuaternion& Set( const CVector4 &in_XYZWVector );

        SICPPSDK_INLINE double GetValue( short in_nIndex ) const;

        SICPPSDK_INLINE CQuaternion& PutValue( short in_nIndex,  double newVal);

        SICPPSDK_INLINE double GetW() const;

        SICPPSDK_INLINE CQuaternion& PutW( double newVal);

        SICPPSDK_INLINE double GetZ() const;

        SICPPSDK_INLINE CQuaternion& PutZ( double newVal);

        SICPPSDK_INLINE double GetY() const;

        SICPPSDK_INLINE CQuaternion& PutY( double newVal);

        SICPPSDK_INLINE double GetX() const;

        SICPPSDK_INLINE CQuaternion& PutX( double newVal);

        CQuaternion& SetFromXYZAnglesValues( double x, double y, double z );

        void GetXYZAnglesValues( double& x, double& y, double& z )const;

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

private:
        double m_dX, m_dY, m_dZ, m_dW;
};

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

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


SICPPSDK_INLINE CQuaternion& CQuaternion::operator=( const CQuaternion & in_Quat )
{
        m_dW = in_Quat.m_dW;
        m_dX = in_Quat.m_dX;
        m_dY = in_Quat.m_dY;
        m_dZ = in_Quat.m_dZ;

        return *this;
}

SICPPSDK_INLINE CQuaternion::CQuaternion( const double in_dW, const double in_dX,
           const double in_dY, const double in_dZ )
{
        Set( in_dW, in_dX, in_dY, in_dZ );
}

SICPPSDK_INLINE CQuaternion::CQuaternion( const XSI::MATH::CVector3& in_vct )
{
        Set( in_vct );
}

SICPPSDK_INLINE CQuaternion::CQuaternion( const XSI::MATH::CVector4& in_vct )
{
        Set( in_vct );
}

SICPPSDK_INLINE bool CQuaternion::Equals( const CQuaternion &in_Quat ) const
{
        return (this == &in_Quat) ? true :
                (m_dW == in_Quat.m_dW &&
                m_dX == in_Quat.m_dX &&
                m_dY == in_Quat.m_dY &&
                m_dZ == in_Quat.m_dZ );
}

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

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

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

        return Mul(*this, in_Quat);
}

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

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

        dW = in_Quat1.m_dW * in_Quat2.m_dW - in_Quat1.m_dX * in_Quat2.m_dX -
                in_Quat1.m_dY * in_Quat2.m_dY - in_Quat1.m_dZ * in_Quat2.m_dZ ;

        dX = in_Quat1.m_dW * in_Quat2.m_dX + in_Quat2.m_dW * in_Quat1.m_dX +
                in_Quat1.m_dY * in_Quat2.m_dZ - in_Quat2.m_dY * in_Quat1.m_dZ ;

        dY = in_Quat1.m_dW * in_Quat2.m_dY + in_Quat2.m_dW * in_Quat1.m_dY -
                in_Quat1.m_dX * in_Quat2.m_dZ + in_Quat2.m_dX * in_Quat1.m_dZ ;

        dZ = in_Quat1.m_dW * in_Quat2.m_dZ + in_Quat2.m_dW * in_Quat1.m_dZ +
                in_Quat1.m_dX * in_Quat2.m_dY - in_Quat2.m_dX * in_Quat1.m_dY ;

        m_dW = dW; m_dX = dX; m_dY = dY; m_dZ = dZ;

        return *this;
}

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

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

SICPPSDK_INLINE CQuaternion& CQuaternion::Sub
( 
        const CQuaternion &in_Quat1,  
        const CQuaternion &in_Quat2
)
{
        m_dW = in_Quat1.m_dW - in_Quat2.m_dW;
        m_dX = in_Quat1.m_dX - in_Quat2.m_dX;
        m_dY = in_Quat1.m_dY - in_Quat2.m_dY;
        m_dZ = in_Quat1.m_dZ - in_Quat2.m_dZ;

        return *this;
}

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

SICPPSDK_INLINE CQuaternion& CQuaternion::Negate( const CQuaternion &in_Quat)
{
   m_dW = -(in_Quat.m_dW);
   m_dX = -(in_Quat.m_dX);
   m_dY = -(in_Quat.m_dY);
   m_dZ = -(in_Quat.m_dZ);

   return( *this );
}

SICPPSDK_INLINE double CQuaternion::GetLengthSquared() const
{
        return( m_dW * m_dW + m_dX * m_dX +     m_dY * m_dY + m_dZ * m_dZ );
}

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

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

SICPPSDK_INLINE CQuaternion& CQuaternion::Add
( 
        const CQuaternion &in_Quat1,  
        const CQuaternion &in_Quat2
)
{
        m_dW = in_Quat1.m_dW + in_Quat2.m_dW;
        m_dX = in_Quat1.m_dX + in_Quat2.m_dX;
        m_dY = in_Quat1.m_dY + in_Quat2.m_dY;
        m_dZ = in_Quat1.m_dZ + in_Quat2.m_dZ;
        return *this;
}

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

SICPPSDK_INLINE CQuaternion& CQuaternion::Conjugate( const CQuaternion &in_Quat)
{
        m_dW = in_Quat.m_dW;
        m_dX = -in_Quat.m_dX;
        m_dY = -in_Quat.m_dY;
        m_dZ = -in_Quat.m_dZ;

        return( *this );
}

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

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

SICPPSDK_INLINE CQuaternion& CQuaternion::SetIdentity()
{
        m_dW = 1.0;
        m_dX = m_dY = m_dZ = 0.0;

        return( *this );
}

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

SICPPSDK_INLINE void CQuaternion::Get
( 
        double &io_dW, 
        double &io_dX, 
        double &io_dY, 
        double &io_dZ 
) const
{
        io_dW = m_dW;
        io_dX = m_dX;
        io_dY = m_dY;
        io_dZ = m_dZ;
}

SICPPSDK_INLINE void CQuaternion::Get( CVector4 &io_XYZWVector ) const
{
        io_XYZWVector.Set( m_dX, m_dY, m_dZ, m_dW);
}


SICPPSDK_INLINE CQuaternion& CQuaternion::Set
( 
        double in_dW,  
        double in_dX,  
        double in_dY,  
        double in_dZ
)
{
        m_dW = in_dW;
        m_dX = in_dX;
        m_dY = in_dY;
        m_dZ = in_dZ;

        return *this;
}

SICPPSDK_INLINE CQuaternion& CQuaternion::Set( const CVector3 &in_XYZVector )
{
        m_dW = 1.0;
        m_dX = in_XYZVector.GetX();
        m_dY = in_XYZVector.GetY();
        m_dZ = in_XYZVector.GetZ();

        return *this;
}

SICPPSDK_INLINE CQuaternion& CQuaternion::Set( const CVector4 &in_XYZWVector )
{
        m_dW = in_XYZWVector.GetW();
        m_dX = in_XYZWVector.GetX();
        m_dY = in_XYZWVector.GetY();
        m_dZ = in_XYZWVector.GetZ();

        return *this;
}

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

        switch (in_nIndex)
        {
                case 0: return m_dW;
                case 1: return m_dX;
                case 2: return m_dY;
                case 3: return m_dZ;
        }

        return 0.0; // invalid index, return 0.0
}

SICPPSDK_INLINE CQuaternion& CQuaternion::PutValue( short in_nIndex,  double newVal)
{
        assert(in_nIndex >= 0 && in_nIndex < 4);

        switch (in_nIndex)
        {
                case 0:  m_dW = newVal; break;
                case 1:  m_dX = newVal; break;
                case 2:  m_dY = newVal; break;
                case 3:  m_dZ = newVal; break;
                // note: do nothing when invalid index is provided
        }

        return *this;
}

SICPPSDK_INLINE double CQuaternion::GetW() const
{
        return m_dW;
}

SICPPSDK_INLINE CQuaternion& CQuaternion::PutW( double newVal)
{
        m_dW = newVal;

        return *this;
}

SICPPSDK_INLINE double CQuaternion::GetZ() const
{
        return m_dZ;
}

SICPPSDK_INLINE CQuaternion& CQuaternion::PutZ( double newVal)
{
        m_dZ = newVal;
        return *this;
}

SICPPSDK_INLINE double CQuaternion::GetY() const
{
        return m_dY;
}

SICPPSDK_INLINE CQuaternion& CQuaternion::PutY( double newVal)
{
        m_dY = newVal;
        return *this;
}


SICPPSDK_INLINE double CQuaternion::GetX() const
{
        return m_dX;
}

SICPPSDK_INLINE CQuaternion& CQuaternion::PutX( double newVal)
{
        m_dX = newVal;
        return *this;
}

SICPPSDK_INLINE CQuaternion::CQuaternion( const CRotation& in_Rot )
{
        *this = in_Rot;
}


};
};

#endif // __XSIQUATERNION_H__