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__