xsi_vector3.h

Go to the documentation of this file.

//*****************************************************************************
//*****************************************************************************

#if (_MSC_VER > 1000) || defined(SGI_COMPILER)
#pragma once
#endif

#ifndef __XSIVECTOR3_H__
#define __XSIVECTOR3_H__

#include "sicppsdk.h"
#include "xsi_status.h"
#include "xsi_matrix3.h"
#include "xsi_matrix4.h"
#include <math.h>

// uncomment this if you want the debug version of your plugin to catch uninitialized CVector3
// #define _DEBUG_NonInitialized_CVector3

#ifdef _DEBUG_NonInitialized_CVector3
#define MAGIC_DEBUG_VALUE ((double)0x5555555555555555)
#define XSI_DEBUG_VECTOR3 SelfDebug();
#else
#define XSI_DEBUG_VECTOR3
#endif


namespace XSI {

namespace MATH {

class CTransformation;
class CMatrix3;
class CMatrix4;

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

        SICPPSDK_INLINE CVector3(double in_dX, double in_dY, double in_dZ);

        SICPPSDK_INLINE CVector3( const CVector3& in_vector3);

        SICPPSDK_INLINE ~CVector3();

        SICPPSDK_INLINE CVector3 & operator=( const CVector3 & in_vector3 );

        SICPPSDK_INLINE bool operator ==(const CVector3 & in_vector3 )const;

        SICPPSDK_INLINE bool operator !=(const CVector3 & in_vector3 )const;

        SICPPSDK_INLINE CVector3& operator ~();

        SICPPSDK_INLINE CVector3& operator +=(const CVector3& in_vector3);

        SICPPSDK_INLINE CVector3& operator -=(const CVector3 & in_vector3);


        SICPPSDK_INLINE CVector3& operator *=(const CMatrix3& in_matrix3);

        SICPPSDK_INLINE CVector3& operator *=(const CMatrix4& in_matrix4);

        SICPPSDK_INLINE CVector3& operator *=(const CTransformation& in_transformation);

        SICPPSDK_INLINE CVector3& operator *=(const double& in_dAlpha);

        SICPPSDK_INLINE double operator[](const short& in_sIndex);

        SICPPSDK_INLINE CVector3& MulByMatrix3InPlace(const CMatrix3& in_matrix3);

        SICPPSDK_INLINE CVector3& MulByMatrix3
        (
                const CVector3& in_vector3,
                const CMatrix3& in_matrix3
        );

        SICPPSDK_INLINE CVector3& MulByMatrix4InPlace(const CMatrix4& in_matrix4);

        SICPPSDK_INLINE CVector3& MulByMatrix4
        (
                const CVector3& in_vector3,
                const CMatrix4& in_matrix4
        );

        SICPPSDK_INLINE CVector3& MulByTransformationInPlace
        (
                const CTransformation& in_transformation
        );

        CVector3& MulByTransformation
        (
                const CVector3&                 in_vector3,
                const CTransformation&  in_transformation
        );

        SICPPSDK_INLINE CVector3& PutNull();

        SICPPSDK_INLINE short GetMaxComponentIndex()const;

        SICPPSDK_INLINE double GetMaxComponent()const;

        SICPPSDK_INLINE short GetMinComponentIndex()const;

        SICPPSDK_INLINE double GetMinComponent()const;

        SICPPSDK_INLINE double GetLength()const;

        SICPPSDK_INLINE double GetLengthSquared()const;

        CStatus NormalizeInPlace();

        CStatus Normalize(const CVector3& in_vector3);

        SICPPSDK_INLINE double Dot(const CVector3& in_vector3)const;


        SICPPSDK_INLINE CVector3& Cross(const CVector3& in_vector3A, const CVector3& in_vector3B);

        double GetAngle(const CVector3& in_vector3 )const;

        SICPPSDK_INLINE CVector3& LinearlyInterpolate
        (
                const CVector3& in_vector3A,
                const CVector3& in_vector3B,
                double in_dAlpha
        );

        CVector3& AbsoluteInPlace();

        CVector3& Absolute(const CVector3& in_vector3);

        CVector3& ClampInPlace(double in_dMinValue, double in_dMaxValue);

        SICPPSDK_INLINE CVector3& Clamp
        (
                double                  in_dMinValue,
                double                  in_dMaxValue,
                const CVector3& in_vector3
        );

        SICPPSDK_INLINE bool EpsilonEquals
        (
                const CVector3& in_vector3,
                double in_dEpsilon
        )const;

        SICPPSDK_INLINE bool Equals(const CVector3& in_vector3)const;


        SICPPSDK_INLINE CVector3& ScaleAddInPlace(double in_dS,const CVector3& in_vector3);

        SICPPSDK_INLINE CVector3& ScaleAdd
        (
                double                  in_dS,
                const CVector3& in_vector3A,
                const CVector3& in_vector3B
        );

        SICPPSDK_INLINE CVector3& ScaleInPlace(double in_dAlpha);

        SICPPSDK_INLINE CVector3& Scale(double in_dAlpha, const CVector3& in_vector3);

        SICPPSDK_INLINE CVector3& NegateInPlace();

        SICPPSDK_INLINE CVector3& Negate(const CVector3& in_vector3);

        SICPPSDK_INLINE CVector3& SubInPlace(const CVector3&in_vector3);

        SICPPSDK_INLINE CVector3& Sub(const CVector3& in_vector3A, const CVector3& in_vector3B);

        SICPPSDK_INLINE CVector3& AddInPlace(const CVector3& in_vector3);

        SICPPSDK_INLINE CVector3& Add(const CVector3& in_vector3A,const CVector3& in_vector3B);

        void Get(double& io_dX, double& io_dY, double& io_dZ)const;

        SICPPSDK_INLINE CVector3& Set(double in_dX, double in_dY, double in_dZ);

        SICPPSDK_INLINE double GetZ()const;

        SICPPSDK_INLINE CVector3& PutZ(double in_dZ);

        SICPPSDK_INLINE double GetY()const;

        SICPPSDK_INLINE CVector3& PutY(double in_dY);

        SICPPSDK_INLINE double GetX()const;

        SICPPSDK_INLINE CVector3& PutX(double in_dX);

#ifdef _DEBUG_NonInitialized_CVector3
        void DoDebugInit()
        {
                m_dX = MAGIC_DEBUG_VALUE;  // 64 bits of alternating 010101010101...
                m_dY = MAGIC_DEBUG_VALUE;  // 64 bits of alternating 010101010101...
                m_dZ = MAGIC_DEBUG_VALUE;  // 64 bits of alternating 010101010101...
        }


        void SelfDebug() const
        {
                assert( m_dX != MAGIC_DEBUG_VALUE && m_dY != MAGIC_DEBUG_VALUE && m_dZ != MAGIC_DEBUG_VALUE );
        }
#endif

private:
        double m_dX,m_dY,m_dZ;
};

//inline functions
SICPPSDK_INLINE CVector3::CVector3()
{
#ifdef _DEBUG_NonInitialized_CVector3
        DoDebugInit(); // This method sets the debug values
#else
        m_dX = 0;
        m_dY = 0;
        m_dZ = 0;
#endif
}

SICPPSDK_INLINE CVector3::CVector3( const CVector3& in_vct )
{
        in_vct.Get(m_dX,m_dY,m_dZ);
}

SICPPSDK_INLINE CVector3::CVector3
(
 double in_dX, double in_dY, double in_dZ
):m_dX(in_dX),m_dY(in_dY),m_dZ(in_dZ)
{}

SICPPSDK_INLINE CVector3::~CVector3()
{}

SICPPSDK_INLINE CVector3& CVector3::operator=( const CVector3 & in_vct )
{
        in_vct.Get(m_dX,m_dY,m_dZ);
        return (*this);
}

SICPPSDK_INLINE bool CVector3::operator ==(const CVector3 & in_vector3 )const
{
        return Equals(in_vector3);
}


SICPPSDK_INLINE bool CVector3::operator !=(const CVector3 & in_vector3 )const
{
        return ! Equals(in_vector3);
}

SICPPSDK_INLINE CVector3& CVector3::operator ~()
{
        return NegateInPlace();
}

SICPPSDK_INLINE CVector3& CVector3::operator +=(const CVector3& in_vector3)
{
        return AddInPlace(in_vector3);
}

SICPPSDK_INLINE CVector3& CVector3::operator -=(const CVector3& in_vector3)
{
        return SubInPlace(in_vector3);
}

SICPPSDK_INLINE CVector3& CVector3::operator *=(const CMatrix3& in_matrix3)
{
        return MulByMatrix3InPlace(in_matrix3);
}

SICPPSDK_INLINE CVector3& CVector3::operator *=(const CMatrix4& in_matrix4)
{
        return MulByMatrix4InPlace(in_matrix4);
}

SICPPSDK_INLINE CVector3& CVector3::operator *=(const CTransformation& in_transformation)
{
        return MulByTransformationInPlace(in_transformation);
}

SICPPSDK_INLINE CVector3& CVector3::operator *=(const double& in_dAlpha)
{
        return ScaleInPlace(in_dAlpha);
}

SICPPSDK_INLINE double CVector3::operator[](const short& in_sIndex)
{
        XSI_DEBUG_VECTOR3;
        assert(in_sIndex >= 0 && in_sIndex < 3);
        switch(in_sIndex)
        {
        case 0:
                return m_dX;
                break;
        case 1:
                return m_dY;
                break;
        case 2:
                return m_dZ;
                break;
        }
        return DBL_MAX;
}

SICPPSDK_INLINE CVector3& CVector3::MulByMatrix3InPlace
(
        const CMatrix3& in_matrix3
)
{
        XSI_DEBUG_VECTOR3;
        return MulByMatrix3((*this),in_matrix3);
}

SICPPSDK_INLINE CVector3& CVector3::MulByMatrix3
(
        const CVector3& in_vector3,
        const CMatrix3& in_matrix3
)
{
        double l_dX, l_dY,l_dZ;
        l_dX = in_vector3.GetX() * in_matrix3.GetValue(0,0) +
                   in_vector3.GetY() * in_matrix3.GetValue(1,0) +
                   in_vector3.GetZ() * in_matrix3.GetValue(2,0);
        l_dY = in_vector3.GetX() * in_matrix3.GetValue(0,1) +
                   in_vector3.GetY() * in_matrix3.GetValue(1,1) +
                   in_vector3.GetZ() * in_matrix3.GetValue(2,1);
        l_dZ = in_vector3.GetX() * in_matrix3.GetValue(0,2) +
                   in_vector3.GetY() * in_matrix3.GetValue(1,2) +
                   in_vector3.GetZ() * in_matrix3.GetValue(2,2);

        return Set(l_dX,l_dY,l_dZ);
}

SICPPSDK_INLINE CVector3& CVector3::MulByMatrix4InPlace
(
        const CMatrix4& in_matrix4
)
{
        XSI_DEBUG_VECTOR3;
        return MulByMatrix4((*this),in_matrix4);
}


SICPPSDK_INLINE CVector3& CVector3::MulByMatrix4
(
        const CVector3& in_vector3,
        const CMatrix4& in_matrix4
)
{
        double l_dX, l_dY, l_dZ, l_dW;

        l_dX =  in_vector3.GetX() * in_matrix4.GetValue( 0, 0 ) +
                        in_vector3.GetY() * in_matrix4.GetValue( 1, 0 ) +
                        in_vector3.GetZ() * in_matrix4.GetValue( 2, 0 ) +
                        in_matrix4.GetValue( 3, 0 );
        l_dY =  in_vector3.GetX() * in_matrix4.GetValue( 0, 1 ) +
                        in_vector3.GetY() * in_matrix4.GetValue( 1, 1 ) +
                        in_vector3.GetZ() * in_matrix4.GetValue( 2, 1 ) +
                        in_matrix4.GetValue( 3, 1 );
        l_dZ =  in_vector3.GetX() * in_matrix4.GetValue( 0, 2 ) +
                        in_vector3.GetY() * in_matrix4.GetValue( 1, 2 ) +
                        in_vector3.GetZ() * in_matrix4.GetValue( 2, 2 ) +
                        in_matrix4.GetValue( 3, 2 );
        l_dW =  in_vector3.GetX() * in_matrix4.GetValue( 0, 3 ) +
                        in_vector3.GetY() * in_matrix4.GetValue( 1, 3 ) +
                        in_vector3.GetZ() * in_matrix4.GetValue( 2, 3 ) +
                        in_matrix4.GetValue( 3, 3 );

        return Set(l_dX/l_dW, l_dY/l_dW, l_dZ/l_dW);
}


SICPPSDK_INLINE CVector3& CVector3::MulByTransformationInPlace
(
        const CTransformation& in_crTrans
)
{
        XSI_DEBUG_VECTOR3;
        return MulByTransformation((*this), in_crTrans);;
}


SICPPSDK_INLINE CVector3& CVector3::PutNull()
{
        m_dX = m_dY = m_dZ = 0.0;
        return (*this);
}

SICPPSDK_INLINE short CVector3::GetMaxComponentIndex()const
{
        XSI_DEBUG_VECTOR3;
        if( m_dX > m_dY )
        {
                return (short)(( m_dX > m_dZ ) ? 0 : 2);
        }
        else
        {
                return (short)(( m_dY > m_dZ ) ? 1 : 2);
        }
}

SICPPSDK_INLINE double CVector3::GetMaxComponent()const
{
        XSI_DEBUG_VECTOR3;
        if( m_dX > m_dY )
        {
                return ( m_dX > m_dZ ) ? m_dX : m_dZ;
        }
        else
        {
                return ( m_dY > m_dZ ) ? m_dY : m_dZ;
        }
}

SICPPSDK_INLINE short CVector3::GetMinComponentIndex()const
{
        XSI_DEBUG_VECTOR3;
        if( m_dX < m_dY )
        {
                return (short)(( m_dX < m_dZ ) ? 0 : 2);
        }
        else
        {
                return (short)(( m_dY < m_dZ ) ? 1 : 2);
        }
}

SICPPSDK_INLINE double CVector3::GetMinComponent()const
{
        XSI_DEBUG_VECTOR3;
        if( m_dX < m_dY )
        {
                return ( m_dX < m_dZ ) ? m_dX : m_dZ;
        }
        else
        {
                return ( m_dY < m_dZ ) ? m_dY : m_dZ;
        }
}

SICPPSDK_INLINE double CVector3::GetLength()const
{
        XSI_DEBUG_VECTOR3;
        return sqrt( GetLengthSquared() );
}

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

SICPPSDK_INLINE double  CVector3::Dot(const CVector3& io_vec3)const
{
        XSI_DEBUG_VECTOR3;
        return ( m_dX*io_vec3.GetX() + m_dY*io_vec3.GetY() + m_dZ*io_vec3.GetZ() );
}

SICPPSDK_INLINE CVector3& CVector3::Cross
(
        const CVector3& in_vec3A,
        const CVector3& in_vec3B
)
{
        double dX, dY, dZ;

        dX =    in_vec3A.GetY() * in_vec3B.GetZ() -
                        in_vec3A.GetZ() * in_vec3B.GetY();
        dY =   -in_vec3A.GetX() * in_vec3B.GetZ() +
                        in_vec3A.GetZ() * in_vec3B.GetX();
        dZ =    in_vec3A.GetX() * in_vec3B.GetY() -
                        in_vec3A.GetY() * in_vec3B.GetX();

   return( Set( dX, dY, dZ ) );
}

SICPPSDK_INLINE CVector3& CVector3::LinearlyInterpolate
(
 const CVector3&        in_vec3A,
 const CVector3&        in_vec3B,
 const double           in_dAlpha
)
{
        m_dX = (1 - in_dAlpha) * in_vec3A.GetX() + in_dAlpha * in_vec3B.GetX();
        m_dY = (1 - in_dAlpha) * in_vec3A.GetY() + in_dAlpha * in_vec3B.GetY();
        m_dZ = (1 - in_dAlpha) * in_vec3A.GetZ() + in_dAlpha * in_vec3B.GetZ();

        return (*this);
}

SICPPSDK_INLINE bool CVector3::EpsilonEquals
(
        const CVector3& in_cVec3,
        double in_dEpsilon
)const
{
        XSI_DEBUG_VECTOR3;
        return (this == &in_cVec3) ? true :
                (fabs( m_dX - in_cVec3.GetX() ) < ::fabs(in_dEpsilon) &&
                   fabs( m_dY - in_cVec3.GetY() ) < ::fabs(in_dEpsilon) &&
                   fabs( m_dZ - in_cVec3.GetZ() ) < ::fabs(in_dEpsilon) );
}


SICPPSDK_INLINE bool CVector3::Equals(const CVector3& in_vec3)const
{
        XSI_DEBUG_VECTOR3;
        return (this == &in_vec3) ? true :
                ( ( m_dX == in_vec3.GetX() ) &&
                  ( m_dY == in_vec3.GetY() ) &&
                  ( m_dZ == in_vec3.GetZ() ) );
}

SICPPSDK_INLINE CVector3& CVector3::ScaleAddInPlace
(
        double in_dScalingFactor,
        const CVector3& in_vec3
)
{
        ScaleInPlace(in_dScalingFactor);
        return AddInPlace(in_vec3);
}


SICPPSDK_INLINE CVector3& CVector3::ScaleAdd
(
        const double in_dScalingFactor,
        const CVector3& in_vec3A,
        const CVector3& in_vec3B
)
{
        Scale(in_dScalingFactor, in_vec3A);
        return AddInPlace(in_vec3B);
}

SICPPSDK_INLINE CVector3& CVector3::ScaleInPlace(double in_dScalingFactor)
{
        XSI_DEBUG_VECTOR3;
        m_dX *= in_dScalingFactor;
        m_dY *= in_dScalingFactor;
        m_dZ *= in_dScalingFactor;
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::Scale
(
 double in_dScalingFactor,
 const CVector3& in_vec3
)
{
        m_dX = in_vec3.GetX() * in_dScalingFactor;
        m_dY = in_vec3.GetY() * in_dScalingFactor;
        m_dZ = in_vec3.GetZ() * in_dScalingFactor;
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::NegateInPlace()
{
        XSI_DEBUG_VECTOR3;
        m_dX = -m_dX;
        m_dY = -m_dY;
        m_dZ = -m_dZ;
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::Negate(const CVector3& in_vec3 )
{
        m_dX = -in_vec3.GetX();
        m_dY = -in_vec3.GetY();
        m_dZ = -in_vec3.GetZ();
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::SubInPlace(const CVector3& in_vec3)
{
        XSI_DEBUG_VECTOR3;
        m_dX -= in_vec3.GetX();
        m_dY -= in_vec3.GetY();
        m_dZ -= in_vec3.GetZ();
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::Sub
(
        const CVector3& in_vec3A,
        const CVector3& in_vec3B
)
{
        m_dX = in_vec3A.GetX() - in_vec3B.GetX();
        m_dY = in_vec3A.GetY() - in_vec3B.GetY();
        m_dZ = in_vec3A.GetZ() - in_vec3B.GetZ();
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::AddInPlace(const CVector3& in_vec3)
{
        XSI_DEBUG_VECTOR3;
        m_dX += in_vec3.GetX();
        m_dY += in_vec3.GetY();
        m_dZ += in_vec3.GetZ();
        return (*this);
}

SICPPSDK_INLINE CVector3& CVector3::Add
(
        const CVector3& in_vec3A,
        const CVector3& in_vec3B
)
{
        m_dX = in_vec3A.GetX() + in_vec3B.GetX();
        m_dY = in_vec3A.GetY() + in_vec3B.GetY();
        m_dZ = in_vec3A.GetZ() + in_vec3B.GetZ();
        return (*this);
}


SICPPSDK_INLINE void CVector3::Get(double& io_rdX, double& io_rdY, double& io_rdZ)const
{
        XSI_DEBUG_VECTOR3;
        io_rdX = m_dX;
        io_rdY = m_dY;
        io_rdZ = m_dZ;
}

SICPPSDK_INLINE CVector3& CVector3::Set(double in_dX, double in_dY, double in_dZ)
{
        m_dX = in_dX;
        m_dY = in_dY;
        m_dZ = in_dZ;
        return (*this);
}

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

SICPPSDK_INLINE CVector3&       CVector3::PutZ(double in_dZ)
{
        m_dZ = in_dZ;
        return (*this);
}

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

SICPPSDK_INLINE CVector3& CVector3::PutY(double in_dY)
{
        m_dY = in_dY;
        return (*this);
}

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

SICPPSDK_INLINE CVector3& CVector3::PutX(double in_dX)
{
        m_dX = in_dX;
        return (*this);
}

//*************************************************************************
//*************************************************************************
class SICPPSDKDECL CVector3Array
{
public:
        CVector3Array( LONG in_size=0);

        CVector3Array(const CVector3Array& in_Array);

        ~CVector3Array();

        CVector3Array& operator=( const CVector3Array& in_array );

        LONG GetCount() const;

        CStatus Add( const CVector3& in_item );

        CStatus Clear();

        CStatus Resize( LONG in_size);

        const CVector3& operator[]( LONG in_index ) const;

        CVector3& operator[]( LONG in_index );

        bool operator==(const CVector3Array& in_array) const;

        bool operator!=(const CVector3Array& in_array) const;


private:

        void* m_ptr;
};

};
};

#endif // __XSIVECTOR3_H__