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__