xsi_vector4f.h

Go to the documentation of this file.

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

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

#ifndef __XSIVECTOR4F_H__
#define __XSIVECTOR4F_H__

#include "sicppsdk.h"
#include "xsi_matrix4f.h"

namespace XSI {

namespace MATH {

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

    SICPPSDK_INLINE CVector4f(float in_fX, float in_fY, float in_fZ, float in_fW);

    SICPPSDK_INLINE CVector4f( const CVector4f& in_vector4);

    SICPPSDK_INLINE ~CVector4f();

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

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

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

    SICPPSDK_INLINE bool operator < ( const CVector4f & in_vector4 ) const;

    SICPPSDK_INLINE CVector4f& operator ~();

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

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

    SICPPSDK_INLINE CVector4f& operator *=(const CMatrix4f& in_matrix4);

    SICPPSDK_INLINE CVector4f& operator *=(const float& in_fAlpha);

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

    SICPPSDK_INLINE CVector4f& MulByMatrix4InPlace(const CMatrix4f& in_matrix4);

    SICPPSDK_INLINE CVector4f& MulByMatrix4
    (
        const CVector4f& in_vector4,
        const CMatrix4f& in_matrix4
    );

    SICPPSDK_INLINE CVector4f& SetNull();

    float GetLength()const;

    float GetLengthSquared()const;

    SICPPSDK_INLINE CStatus NormalizeInPlace();

    SICPPSDK_INLINE CStatus Normalize(const CVector4f& in_vector4);

    SICPPSDK_INLINE float Dot(const CVector4f& in_vector4)const;

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

    CVector4f& AbsoluteInPlace();

    CVector4f& Absolute(const CVector4f& in_vector4);

    bool EpsilonEquals( const CVector4f& in_vector4, float in_fEpsilon) const;

    SICPPSDK_INLINE bool Equals(const CVector4f& in_vector4)const;

    SICPPSDK_INLINE CVector4f& ScaleAddInPlace(float in_fS,const CVector4f& in_vector4);

    SICPPSDK_INLINE CVector4f& ScaleAdd
    (
        float               in_fS,
        const CVector4f&    in_vector4A,
        const CVector4f&    in_vector4B
    );

    SICPPSDK_INLINE CVector4f& ScaleInPlace(float in_fAlpha);

    SICPPSDK_INLINE CVector4f& Scale(float in_fAlpha, const CVector4f& in_vector4);

    SICPPSDK_INLINE CVector4f& NegateInPlace();

    SICPPSDK_INLINE CVector4f& Negate(const CVector4f& in_vector4);

    SICPPSDK_INLINE CVector4f& SubInPlace(const CVector4f& in_vector4);

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

    SICPPSDK_INLINE CVector4f& AddInPlace(const CVector4f& in_vector4);

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

    SICPPSDK_INLINE void Get( float& out_fX, float& out_fY, float& out_fZ, float& out_fW )const;

    SICPPSDK_INLINE CVector4f& Set(float in_fX, float in_fY, float in_fZ, float in_fW);

    SICPPSDK_INLINE float GetW()const;

    SICPPSDK_INLINE CVector4f& PutW(float in_fW);

    SICPPSDK_INLINE float GetZ()const;

    SICPPSDK_INLINE CVector4f& PutZ(float in_fZ);

    SICPPSDK_INLINE float GetY()const;

    SICPPSDK_INLINE CVector4f& PutY(float in_fY);

    SICPPSDK_INLINE float GetX()const;

    SICPPSDK_INLINE CVector4f& PutX(float in_fX);

private:
    float m_fX,m_fY,m_fZ,m_fW;
};

SICPPSDK_INLINE CVector4f::CVector4f(): m_fX(0.0),m_fY(0.0),m_fZ(0.0), m_fW(0.0)
{}

SICPPSDK_INLINE CVector4f::CVector4f
(
 float in_fX, float in_fY, float in_fZ, float in_fW
):m_fX(in_fX),m_fY(in_fY),m_fZ(in_fZ), m_fW(in_fW)
{}

SICPPSDK_INLINE CVector4f::~CVector4f()
{}

SICPPSDK_INLINE CVector4f::CVector4f( const CVector4f& in_vct )
{
    in_vct.Get(m_fX,m_fY,m_fZ,m_fW);
}

SICPPSDK_INLINE CVector4f& CVector4f::operator=( const CVector4f & in_vct )
{
    in_vct.Get(m_fX,m_fY,m_fZ,m_fW);
    return (*this);
}

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

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

SICPPSDK_INLINE bool CVector4f::operator < ( const CVector4f& in_vector4 ) const
{
    if ( m_fW != in_vector4.m_fW ) return m_fW < in_vector4.m_fW;
    if ( m_fZ != in_vector4.m_fZ ) return m_fZ < in_vector4.m_fZ;
    if ( m_fY != in_vector4.m_fY ) return m_fY < in_vector4.m_fY;
    if ( m_fX != in_vector4.m_fX ) return m_fX < in_vector4.m_fX;
    return false;
}

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

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

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

SICPPSDK_INLINE CVector4f& CVector4f::operator *=(const CMatrix4f& in_matrix4)
{
    return MulByMatrix4InPlace(in_matrix4);
}

SICPPSDK_INLINE CVector4f& CVector4f::operator *=(const float& in_fAlpha)
{
    return ScaleInPlace(in_fAlpha);
}

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

SICPPSDK_INLINE CVector4f& CVector4f::MulByMatrix4
(
    const CVector4f& in_vector4,
    const CMatrix4f& in_matrix4
)
{
    float l_fX, l_fY, l_fZ, l_fW;

    l_fX =  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_fY =  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_fZ =  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_fW =  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_fX, l_fY, l_fZ, l_fW);
}

SICPPSDK_INLINE CVector4f& CVector4f::SetNull()
{
    m_fX = m_fY = m_fZ = m_fW = 0.0;
    return (*this);
}

SICPPSDK_INLINE float CVector4f::Dot(const CVector4f& in_vector4)const
{

    return ( m_fX*in_vector4.GetX() + m_fY*in_vector4.GetY() +
            m_fZ*in_vector4.GetZ() + m_fW*in_vector4.GetW());
}

SICPPSDK_INLINE bool CVector4f::Equals(const CVector4f& in_vector4)const
{
    return (this == &in_vector4) ? true :
            ( ( m_fX == in_vector4.GetX() ) &&
              ( m_fY == in_vector4.GetY() ) &&
              ( m_fZ == in_vector4.GetZ() ) &&
              ( m_fW == in_vector4.GetW() ) );
}

SICPPSDK_INLINE CVector4f& CVector4f::ScaleAddInPlace
(
    float in_fScalingFactor,
    const CVector4f& in_vector4
)
{
    ScaleInPlace(in_fScalingFactor);
    return AddInPlace(in_vector4);
}

SICPPSDK_INLINE CVector4f& CVector4f::ScaleAdd
(
    const float in_fScalingFactor,
    const CVector4f& in_vector4A,
    const CVector4f& in_vector4B
)
{
    Scale(in_fScalingFactor, in_vector4A);
    return AddInPlace(in_vector4B);
}

SICPPSDK_INLINE CVector4f& CVector4f::ScaleInPlace(float in_fScalingFactor)
{
    m_fX *= in_fScalingFactor;
    m_fY *= in_fScalingFactor;
    m_fZ *= in_fScalingFactor;
    m_fW *= in_fScalingFactor;
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::Scale
(
 float in_fScalingFactor,
 const CVector4f& in_vector4
)
{
    m_fX = in_vector4.GetX() * in_fScalingFactor;
    m_fY = in_vector4.GetY() * in_fScalingFactor;
    m_fZ = in_vector4.GetZ() * in_fScalingFactor;
    m_fW = in_vector4.GetW() * in_fScalingFactor;
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::NegateInPlace()
{
    m_fX = -m_fX;
    m_fY = -m_fY;
    m_fZ = -m_fZ;
    m_fW = -m_fW;
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::Negate(const CVector4f& in_vector4 )
{
    m_fX = -in_vector4.GetX();
    m_fY = -in_vector4.GetY();
    m_fZ = -in_vector4.GetZ();
    m_fW = -in_vector4.GetW();
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::SubInPlace(const CVector4f& in_vector4)
{
    m_fX -= in_vector4.GetX();
    m_fY -= in_vector4.GetY();
    m_fZ -= in_vector4.GetZ();
    m_fW -= in_vector4.GetW();
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::Sub
(
    const CVector4f& in_vector4A,
    const CVector4f& in_vector4B
)
{
    m_fX = in_vector4A.GetX() - in_vector4B.GetX();
    m_fY = in_vector4A.GetY() - in_vector4B.GetY();
    m_fZ = in_vector4A.GetZ() - in_vector4B.GetZ();
    m_fW = in_vector4A.GetW() - in_vector4B.GetW();
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::AddInPlace(const CVector4f& in_vector4)
{
    m_fX += in_vector4.GetX();
    m_fY += in_vector4.GetY();
    m_fZ += in_vector4.GetZ();
    m_fW += in_vector4.GetW();
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::Add
(
    const CVector4f& in_vector4A,
    const CVector4f& in_vector4B
)
{
    m_fX = in_vector4A.GetX() + in_vector4B.GetX();
    m_fY = in_vector4A.GetY() + in_vector4B.GetY();
    m_fZ = in_vector4A.GetZ() + in_vector4B.GetZ();
    m_fW = in_vector4A.GetW() + in_vector4B.GetW();
    return (*this);
}

SICPPSDK_INLINE void CVector4f::Get
(
    float& out_rdX,
    float& out_rdY,
    float& out_rdZ,
    float& out_rdW
)const
{
    out_rdX = m_fX;
    out_rdY = m_fY;
    out_rdZ = m_fZ;
    out_rdW = m_fW;
}

SICPPSDK_INLINE CVector4f& CVector4f::Set
(
    float in_fX,
    float in_fY,
    float in_fZ,
    float in_fW
)
{
    m_fX = in_fX;
    m_fY = in_fY;
    m_fZ = in_fZ;
    m_fW = in_fW;
    return (*this);
}

SICPPSDK_INLINE float CVector4f::GetW()const
{
    return m_fW;
}

SICPPSDK_INLINE CVector4f&  CVector4f::PutW(float in_fW)
{
    m_fW = in_fW;
    return (*this);
}

SICPPSDK_INLINE float CVector4f::GetZ()const
{
    return m_fZ;
}

SICPPSDK_INLINE CVector4f&  CVector4f::PutZ(float in_fZ)
{
    m_fZ = in_fZ;
    return (*this);
}

SICPPSDK_INLINE float CVector4f::GetY()const
{
    return m_fY;
}

SICPPSDK_INLINE CVector4f& CVector4f::PutY(float in_fY)
{
    m_fY = in_fY;
    return (*this);
}

SICPPSDK_INLINE float CVector4f::GetX()const
{
    return m_fX;
}

SICPPSDK_INLINE CVector4f& CVector4f::PutX(float in_fX)
{
    m_fX = in_fX;
    return (*this);
}

SICPPSDK_INLINE float CVector4f::operator[](const short& in_sIndex)
{
    assert(in_sIndex >= 0 && in_sIndex < 4);
    switch(in_sIndex)
    {
        case 0:
            return m_fX;
            break;
        case 1:
            return m_fY;
            break;
        case 2:
            return m_fZ;
            break;
        case 3:
            return m_fW;
            break;
    }
    return FLT_MAX;
}

SICPPSDK_INLINE CVector4f& CVector4f::AbsoluteInPlace()
{
    ::fabs(m_fX);
    ::fabs(m_fY);
    ::fabs(m_fZ);
    ::fabs(m_fW);
    return (*this);
}

SICPPSDK_INLINE CVector4f& CVector4f::Absolute(const CVector4f& in_vector4)
{
    float dX, dY, dZ, dW;
    in_vector4.Get(dX, dY, dZ, dW);
    m_fX = ::fabs(dX);
    m_fY = ::fabs(dY);
    m_fZ = ::fabs(dZ);
    m_fW = ::fabs(dW);

    return (*this);
}
SICPPSDK_INLINE bool CVector4f::EpsilonEquals
(
    const CVector4f& in_vector4,
    float in_fEpsilon
)const
{
    return (this == &in_vector4) ? true :
        (fabs( m_fX - in_vector4.GetX() ) < ::fabs(in_fEpsilon) &&
         fabs( m_fY - in_vector4.GetY() ) < ::fabs(in_fEpsilon) &&
         fabs( m_fZ - in_vector4.GetZ() ) < ::fabs(in_fEpsilon) &&
         fabs( m_fW - in_vector4.GetW() ) < ::fabs(in_fEpsilon));
}

SICPPSDK_INLINE float CVector4f::GetLength()const
{
    return sqrt( GetLengthSquared() );
}

SICPPSDK_INLINE float CVector4f::GetLengthSquared()const
{
     return(m_fX*m_fX + m_fY*m_fY + m_fZ*m_fZ  + m_fW*m_fW);
}

SICPPSDK_INLINE CStatus CVector4f::NormalizeInPlace()
{
    float rLen = GetLength();

    if ( rLen > MicroEPS )
    {
        m_fX /= rLen ;
        m_fY /= rLen ;
        m_fZ /= rLen ;
        m_fW /= rLen ;
        return CStatus::OK;
    }

    return CStatus::Fail;
}

SICPPSDK_INLINE CStatus CVector4f::Normalize(const CVector4f& in_vector4)
{
    float rLen = in_vector4.GetLength();

    if ( rLen > MicroEPS )
    {
        m_fX = in_vector4.GetX() / rLen ;
        m_fY = in_vector4.GetY() / rLen ;
        m_fZ = in_vector4.GetZ() / rLen ;
        m_fW = in_vector4.GetW() / rLen ;
        return CStatus::OK;
    }

    return CStatus::Fail;
}

};
};

#endif // __XSIVECTOR4_H__