xsi_vector4.h

Go to the documentation of this file.

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

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

#ifndef __XSIVECTOR4_H__
#define __XSIVECTOR4_H__

#include "sicppsdk.h"
#include "xsi_status.h"
#include "xsi_matrix4.h"
#include "xsi_transformation.h"


namespace XSI {


namespace MATH {

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

        SICPPSDK_INLINE CVector4(double in_dX, double in_dY, double in_dZ, double in_dW);

        SICPPSDK_INLINE CVector4( const CVector4& in_vector4);

        SICPPSDK_INLINE ~CVector4();

        SICPPSDK_INLINE CVector4 & operator=( const CVector4 & in_vector4 );

        SICPPSDK_INLINE bool operator ==(const CVector4 & in_vector4 )const;

        SICPPSDK_INLINE bool operator !=(const CVector4 & in_vector4 )const;

        SICPPSDK_INLINE CVector4& operator ~();

        SICPPSDK_INLINE CVector4& operator +=(const CVector4& in_vector4);

        SICPPSDK_INLINE CVector4& operator -=(const CVector4 & in_vector4);


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

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

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

        double operator[](const short& in_sIndex);

        SICPPSDK_INLINE CVector4& MulByMatrix4InPlace(const CMatrix4& in_matrix4);

        SICPPSDK_INLINE CVector4& MulByMatrix4
        (
                const CVector4& in_vector4,
                const CMatrix4& in_matrix4
        );

        SICPPSDK_INLINE CVector4& MulByTransformationInPlace
        (
                const CTransformation& in_transformation
        );

        SICPPSDK_INLINE CVector4& MulByTransformation
        (
                const CVector4&                 in_vector4,
                const CTransformation&  in_transformation
        );

        SICPPSDK_INLINE CVector4& PutNull();

        double GetLength()const;

        double GetLengthSquared()const;

        CStatus NormalizeInPlace();

        CStatus Normalize(const CVector4& in_vector4);

        SICPPSDK_INLINE double Dot(const CVector4& in_vector4)const;


        SICPPSDK_INLINE CVector4& Cross(const CVector4& in_vector4A, const CVector4& in_vector4B);

        CVector4& AbsoluteInPlace();

        CVector4& Absolute(const CVector4& in_vector4);

        bool EpsilonEquals
        (
                const CVector4& in_vector4,
                double in_dEpsilon
        )const;

        SICPPSDK_INLINE bool Equals(const CVector4& in_vector4)const;


        SICPPSDK_INLINE CVector4& ScaleAddInPlace(double in_dS,const CVector4& in_vector4);

        SICPPSDK_INLINE CVector4& ScaleAdd
        (
                double                  in_dS,
                const CVector4& in_vector4A,
                const CVector4& in_vector4B
        );

        SICPPSDK_INLINE CVector4& ScaleInPlace(double in_dAlpha);

        SICPPSDK_INLINE CVector4& Scale(double in_dAlpha, const CVector4& in_vector4);

        SICPPSDK_INLINE CVector4& NegateInPlace();

        SICPPSDK_INLINE CVector4& Negate(const CVector4& in_vector4);

        SICPPSDK_INLINE CVector4& SubInPlace(const CVector4& in_vector4);

        SICPPSDK_INLINE CVector4& Sub(const CVector4& in_vector4A, const CVector4& in_vector4B);

        SICPPSDK_INLINE CVector4& AddInPlace(const CVector4& in_vector4);

        SICPPSDK_INLINE CVector4& Add(const CVector4& in_vector4A,const CVector4& in_vector4B);

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

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

        SICPPSDK_INLINE double GetW()const;

        SICPPSDK_INLINE CVector4& PutW(double in_dW);


        SICPPSDK_INLINE double GetZ()const;

        SICPPSDK_INLINE CVector4& PutZ(double in_dZ);

        SICPPSDK_INLINE double GetY()const;

        SICPPSDK_INLINE CVector4& PutY(double in_dY);

        SICPPSDK_INLINE double GetX()const;

        SICPPSDK_INLINE CVector4& PutX(double in_dX);

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

//inline functions
SICPPSDK_INLINE CVector4::CVector4(): m_dX(0.0),m_dY(0.0),m_dZ(0.0), m_dW(0.0)
{}

SICPPSDK_INLINE CVector4::CVector4
(
 double in_dX, double in_dY, double in_dZ, double in_dW
):m_dX(in_dX),m_dY(in_dY),m_dZ(in_dZ), m_dW(in_dW)
{}

SICPPSDK_INLINE CVector4::~CVector4()
{}

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

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


SICPPSDK_INLINE bool CVector4::operator ==(const CVector4 & in_vector4 )const
{
        return Equals(in_vector4);
}


SICPPSDK_INLINE bool CVector4::operator !=(const CVector4 & in_vector4 )const
{
        return ! Equals(in_vector4);
}

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

SICPPSDK_INLINE CVector4& CVector4::operator +=(const CVector4& in_vector4)
{
        return AddInPlace(in_vector4);
}

SICPPSDK_INLINE CVector4& CVector4::operator -=(const CVector4& in_vector4)
{
        return SubInPlace(in_vector4);
}

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

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

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


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


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

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

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


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


SICPPSDK_INLINE CVector4& CVector4::MulByTransformation
(
        const CVector4& in_vector4,
        const CTransformation& in_trans
)
{
        CMatrix4 l_matrix4 = in_trans.GetMatrix4();

        double l_dX, l_dY, l_dZ, l_dW;

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


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


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


SICPPSDK_INLINE double  CVector4::Dot(const CVector4& in_vector4)const
{

        return ( m_dX*in_vector4.GetX() + m_dY*in_vector4.GetY() +
                        m_dZ*in_vector4.GetZ() + m_dW*in_vector4.GetW());
}

SICPPSDK_INLINE bool CVector4::Equals(const CVector4& in_vector4)const
{
        return (this == &in_vector4) ? true :
                        ( ( m_dX == in_vector4.GetX() ) &&
                          ( m_dY == in_vector4.GetY() ) &&
                          ( m_dZ == in_vector4.GetZ() ) &&
                          ( m_dW == in_vector4.GetW() ) );
}

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


SICPPSDK_INLINE CVector4& CVector4::ScaleAdd
(
        const double in_dScalingFactor,
        const CVector4& in_vector4A,
        const CVector4& in_vector4B
)
{
        Scale(in_dScalingFactor, in_vector4A);
        return AddInPlace(in_vector4B);
}

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

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

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

SICPPSDK_INLINE CVector4& CVector4::Negate(const CVector4& in_vector4 )
{
        m_dX = -in_vector4.GetX();
        m_dY = -in_vector4.GetY();
        m_dZ = -in_vector4.GetZ();
        m_dW = -in_vector4.GetW();
        return (*this);
}

SICPPSDK_INLINE CVector4& CVector4::SubInPlace(const CVector4& in_vector4)
{
        m_dX -= in_vector4.GetX();
        m_dY -= in_vector4.GetY();
        m_dZ -= in_vector4.GetZ();
        m_dW -= in_vector4.GetW();
        return (*this);
}

SICPPSDK_INLINE CVector4& CVector4::Sub
(
        const CVector4& in_vector4A,
        const CVector4& in_vector4B
)
{
        m_dX = in_vector4A.GetX() - in_vector4B.GetX();
        m_dY = in_vector4A.GetY() - in_vector4B.GetY();
        m_dZ = in_vector4A.GetZ() - in_vector4B.GetZ();
        m_dW = in_vector4A.GetW() - in_vector4B.GetW();
        return (*this);
}

SICPPSDK_INLINE CVector4& CVector4::AddInPlace(const CVector4& in_vector4)
{
        m_dX += in_vector4.GetX();
        m_dY += in_vector4.GetY();
        m_dZ += in_vector4.GetZ();
        m_dW += in_vector4.GetW();
        return (*this);
}

SICPPSDK_INLINE CVector4& CVector4::Add
(
        const CVector4& in_vector4A,
        const CVector4& in_vector4B
)
{
        m_dX = in_vector4A.GetX() + in_vector4B.GetX();
        m_dY = in_vector4A.GetY() + in_vector4B.GetY();
        m_dZ = in_vector4A.GetZ() + in_vector4B.GetZ();
        m_dW = in_vector4A.GetW() + in_vector4B.GetW();
        return (*this);
}


SICPPSDK_INLINE void CVector4::Get
(
        double& out_rdX,
        double& out_rdY,
        double& out_rdZ,
        double& out_rdW
)const
{
        out_rdX = m_dX;
        out_rdY = m_dY;
        out_rdZ = m_dZ;
        out_rdW = m_dW;
}

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

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

SICPPSDK_INLINE CVector4&       CVector4::PutW(double in_dW)
{
        m_dW = in_dW;
        return (*this);
}

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

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

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

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

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

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

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

        CVector4Array(const CVector4Array& in_ArrayToCopy);

        ~CVector4Array();

        CVector4Array& operator=( const CVector4Array& in_array );

        LONG GetCount() const;

        CStatus Add( const CVector4& in_item );

        CStatus Clear();

        CStatus Resize( LONG in_size);

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

        CVector4& operator[]( LONG in_index );

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

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

private:

        void* m_ptr;
};

};
};

#endif // __XSIVECTOR4_H__