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__