xsi_vector3f.h

Go to the documentation of this file.

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

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

#ifndef __XSIVECTOR3F_H__
#define __XSIVECTOR3F_H__

#include "sicppsdk.h"
#include <xsi_math.h>
#include <xsi_matrix3f.h>
#include <xsi_matrix4f.h>

namespace XSI {

namespace MATH {

//*****************************************************************************
//*****************************************************************************
class CVector3f
{
public:
    SICPPSDK_INLINE CVector3f();

    SICPPSDK_INLINE CVector3f(float in_fX, float in_fY, float in_fZ);

    SICPPSDK_INLINE CVector3f( const CVector3f& in_vector3);

    SICPPSDK_INLINE ~CVector3f();

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

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

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

    SICPPSDK_INLINE CVector3f& operator ~();

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

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

    SICPPSDK_INLINE CVector3f& operator *=(const CMatrix3f& in_matrix3);

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

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

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

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

    SICPPSDK_INLINE bool operator < ( const CVector3f & in_vector3 ) const;

    SICPPSDK_INLINE CVector3f& MulByMatrix3InPlace(const CMatrix3f& in_matrix3);

    SICPPSDK_INLINE CVector3f& MulByMatrix3( const CVector3f& in_vector3, const CMatrix3f& in_matrix3 );

    SICPPSDK_INLINE CVector3f& MulByMatrix4InPlace(const CMatrix4f& in_matrix4);

    SICPPSDK_INLINE CVector3f& MulByMatrix4( const CVector3f& in_vector3, const CMatrix4f& in_matrix4 );

    SICPPSDK_INLINE CVector3f& SetNull();

    SICPPSDK_INLINE bool IsNull(const float in_fEpsilon = MicroEPS);

    SICPPSDK_INLINE short GetMaxComponentIndex()const;

    SICPPSDK_INLINE float GetMaxComponent()const;

    SICPPSDK_INLINE short GetMinComponentIndex()const;

    SICPPSDK_INLINE float GetMinComponent()const;

    SICPPSDK_INLINE float GetLength()const;

    SICPPSDK_INLINE void SetLength( const float in_val );

    SICPPSDK_INLINE float GetLengthSquared()const;

    SICPPSDK_INLINE CStatus NormalizeInPlace();

    SICPPSDK_INLINE CStatus Normalize(const CVector3f& in_vector3);

    SICPPSDK_INLINE float Dot(const CVector3f& in_vector3)const;

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

    SICPPSDK_INLINE float GetAngle(const CVector3f& in_vector3 )const;

    SICPPSDK_INLINE CVector3f& LinearlyInterpolate
    (
        const CVector3f& in_vector3A,
        const CVector3f& in_vector3B,
        const float in_fAlpha
    );

    SICPPSDK_INLINE CVector3f& AbsoluteInPlace();

    SICPPSDK_INLINE CVector3f& Absolute(const CVector3f& in_vector3);

    SICPPSDK_INLINE CVector3f& ClampInPlace(const float in_fMinValue, const float in_fMaxValue);

    SICPPSDK_INLINE CVector3f& Clamp
    (
        const float         in_fMinValue,
        const float         in_fMaxValue,
        const CVector3f&    in_vector3
    );

    SICPPSDK_INLINE bool EpsilonEquals
    (
        const CVector3f& in_vector3,
        const float in_fEpsilon
    )const;

    SICPPSDK_INLINE bool Equals(const CVector3f& in_vector3)const;

    SICPPSDK_INLINE CVector3f& ScaleAddInPlace(const float in_fS,const CVector3f& in_vector3);

    SICPPSDK_INLINE CVector3f& ScaleAdd
    (
        const float             in_fS,
        const CVector3f&        in_vector3A,
        const CVector3f&        in_vector3B
    );

    SICPPSDK_INLINE CVector3f& ScaleInPlace(const float in_fAlpha);

    SICPPSDK_INLINE CVector3f& Scale(const float in_fAlpha, const CVector3f& in_vector3);

    SICPPSDK_INLINE CVector3f& NegateInPlace();

    SICPPSDK_INLINE CVector3f& Negate(const CVector3f& in_vector3);

    SICPPSDK_INLINE CVector3f& SubInPlace(const CVector3f&in_vector3);

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

    SICPPSDK_INLINE CVector3f& AddInPlace(const CVector3f& in_vector3);

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

    SICPPSDK_INLINE float Get(const short& in_sIndex)const;

    SICPPSDK_INLINE void Set(const short& in_sIndex, const float in_val );

    SICPPSDK_INLINE void Get(float& io_fX, float& io_fY, float& io_fZ)const;

    SICPPSDK_INLINE CVector3f& Set(const float in_fX, const float in_fY, const float in_fZ);

    SICPPSDK_INLINE float GetZ()const;

    SICPPSDK_INLINE CVector3f& PutZ(const float in_fZ);

    SICPPSDK_INLINE float GetY()const;

    SICPPSDK_INLINE CVector3f& PutY(const float in_fY);

    SICPPSDK_INLINE float GetX()const;

    SICPPSDK_INLINE CVector3f& PutX(const float in_fX);

private:
    float m_fX,m_fY,m_fZ;
};

//inline functions
SICPPSDK_INLINE CVector3f::CVector3f()
{
    m_fX = 0;
    m_fY = 0;
    m_fZ = 0;
}

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

SICPPSDK_INLINE CVector3f::CVector3f
(
 float in_fX, float in_fY, float in_fZ
):m_fX(in_fX),m_fY(in_fY),m_fZ(in_fZ)
{}

SICPPSDK_INLINE CVector3f::~CVector3f()
{}

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

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

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

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

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

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

SICPPSDK_INLINE CVector3f& CVector3f::operator *=(const CMatrix3f& in_matrix3)
{
    return MulByMatrix3InPlace(in_matrix3);
}

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

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

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

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

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

SICPPSDK_INLINE float CVector3f::Get(const short& in_sIndex) const
{
    assert(in_sIndex >= 0 && in_sIndex < 3);
    switch(in_sIndex)
    {
        case 0:
            return m_fX;
            break;
        case 1:
            return m_fY;
            break;
        case 2:
            return m_fZ;
            break;
    }
    return FLT_MAX;
}

SICPPSDK_INLINE void CVector3f::Set(const short& in_sIndex, const float in_value )
{
    assert(in_sIndex >= 0 && in_sIndex < 3);
    switch(in_sIndex)
    {
        case 0:m_fX = in_value;
        case 1:m_fY = in_value;
        case 2:m_fZ = in_value;
    }
}

SICPPSDK_INLINE CVector3f& CVector3f::MulByMatrix3InPlace(const CMatrix3f& in_matrix3)
{
    return MulByMatrix3((*this),in_matrix3);
}

SICPPSDK_INLINE CVector3f& CVector3f::MulByMatrix3
(
    const CVector3f& in_vector3,
    const CMatrix3f& in_matrix3
)
{
    float l_fX, l_fY,l_fZ;
    l_fX = 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_fY = 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_fZ = 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_fX,l_fY,l_fZ);
}

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

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

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

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

SICPPSDK_INLINE bool CVector3f::IsNull( const float in_fEpsilon )
{
    return( fabs(m_fX) <= in_fEpsilon && fabs(m_fY)<= in_fEpsilon && fabs(m_fZ)<= in_fEpsilon );
}

SICPPSDK_INLINE short CVector3f::GetMaxComponentIndex()const
{
    if( m_fX > m_fY )
    {
        return (short)(( m_fX > m_fZ ) ? 0 : 2);
    }
    else
    {
        return (short)(( m_fY > m_fZ ) ? 1 : 2);
    }
    return 0;
}

SICPPSDK_INLINE float CVector3f::GetMaxComponent()const
{
    if( m_fX > m_fY )
    {
        return ( m_fX > m_fZ ) ? m_fX : m_fZ;
    }
    else
    {
        return ( m_fY > m_fZ ) ? m_fY : m_fZ;
    }
    return 0.0;
}

SICPPSDK_INLINE short CVector3f::GetMinComponentIndex()const
{
    if( m_fX < m_fY )
    {
        return (short)(( m_fX < m_fZ ) ? 0 : 2);
    }
    else
    {
        return (short)(( m_fY < m_fZ ) ? 1 : 2);
    }
    return 0;
}

SICPPSDK_INLINE float CVector3f::GetMinComponent()const
{
    if( m_fX < m_fY )
    {
        return ( m_fX < m_fZ ) ? m_fX : m_fZ;
    }
    else
    {
        return ( m_fY < m_fZ ) ? m_fY : m_fZ;
    }
    return 0.0;
}

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

SICPPSDK_INLINE void CVector3f::SetLength(const float in_val)
{
    float rLen = GetLength();

    if ( rLen > MicroEPS )
    {
        ScaleInPlace( in_val / rLen );
    }
}

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

SICPPSDK_INLINE float CVector3f::Dot(const CVector3f& io_vec3)const
{
    return ( m_fX*io_vec3.GetX() + m_fY*io_vec3.GetY() + m_fZ*io_vec3.GetZ() );
}

SICPPSDK_INLINE CVector3f& CVector3f::Cross
(
    const CVector3f& in_vec3A,
    const CVector3f& in_vec3B
)
{
    float 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 CVector3f& CVector3f::LinearlyInterpolate
(
    const CVector3f&    in_vec3A,
    const CVector3f&    in_vec3B,
    const float         in_fAlpha
)
{
    m_fX = (1 - in_fAlpha) * in_vec3A.GetX() + in_fAlpha * in_vec3B.GetX();
    m_fY = (1 - in_fAlpha) * in_vec3A.GetY() + in_fAlpha * in_vec3B.GetY();
    m_fZ = (1 - in_fAlpha) * in_vec3A.GetZ() + in_fAlpha * in_vec3B.GetZ();

    return (*this);
}

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


SICPPSDK_INLINE bool CVector3f::Equals(const CVector3f& in_vec3)const
{
    return (this == &in_vec3) ? true :
        ( ( m_fX == in_vec3.GetX() ) &&
          ( m_fY == in_vec3.GetY() ) &&
          ( m_fZ == in_vec3.GetZ() ) );
}

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


SICPPSDK_INLINE CVector3f& CVector3f::ScaleAdd
(
    const float in_fScalingFactor,
    const CVector3f& in_vec3A,
    const CVector3f& in_vec3B
)
{
    Scale(in_fScalingFactor, in_vec3A);
    return AddInPlace(in_vec3B);
}

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

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

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

SICPPSDK_INLINE CVector3f& CVector3f::Negate(const CVector3f& in_vec3 )
{
    m_fX = -in_vec3.GetX();
    m_fY = -in_vec3.GetY();
    m_fZ = -in_vec3.GetZ();
    return (*this);
}

SICPPSDK_INLINE CVector3f& CVector3f::SubInPlace(const CVector3f& in_vec3)
{
    m_fX -= in_vec3.GetX();
    m_fY -= in_vec3.GetY();
    m_fZ -= in_vec3.GetZ();
    return (*this);
}

SICPPSDK_INLINE CVector3f& CVector3f::Sub
(
    const CVector3f& in_vec3A,
    const CVector3f& in_vec3B
)
{
    m_fX = in_vec3A.GetX() - in_vec3B.GetX();
    m_fY = in_vec3A.GetY() - in_vec3B.GetY();
    m_fZ = in_vec3A.GetZ() - in_vec3B.GetZ();
    return (*this);
}

SICPPSDK_INLINE CVector3f& CVector3f::AddInPlace(const CVector3f& in_vec3)
{
    m_fX += in_vec3.GetX();
    m_fY += in_vec3.GetY();
    m_fZ += in_vec3.GetZ();
    return (*this);
}

SICPPSDK_INLINE CVector3f& CVector3f::Add
(
    const CVector3f& in_vec3A,
    const CVector3f& in_vec3B
)
{
    m_fX = in_vec3A.GetX() + in_vec3B.GetX();
    m_fY = in_vec3A.GetY() + in_vec3B.GetY();
    m_fZ = in_vec3A.GetZ() + in_vec3B.GetZ();
    return (*this);
}

SICPPSDK_INLINE void CVector3f::Get(float& io_rfX, float& io_rfY, float& io_rfZ)const
{
    io_rfX = m_fX;
    io_rfY = m_fY;
    io_rfZ = m_fZ;
}

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

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

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

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

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

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

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

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

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

    return CStatus::Fail;
}

SICPPSDK_INLINE CStatus CVector3f::Normalize(const CVector3f& in_vec3)
{
    float rLen = in_vec3.GetLength();

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

    return CStatus::Fail;
}

SICPPSDK_INLINE float CVector3f::GetAngle( const CVector3f& in_vec3 ) const
{
    float fCosAngle, fLen;

    fLen = GetLength();
    fLen *= in_vec3.GetLength();
    if( fLen < MicroEPS )
    {
        return( 0.0 );
    }
    else
    {
        fCosAngle = ( m_fX*in_vec3.GetX() + m_fY*in_vec3.GetY() + m_fZ*in_vec3.GetZ() ) / fLen;
        LimitValue( fCosAngle, -1.0, 1.0 );
        return( acos( fCosAngle ) );
    }
    return( 0.0 );
}

SICPPSDK_INLINE CVector3f& CVector3f::AbsoluteInPlace()
{
    float l_fX, l_fY, l_fZ;
    Get(l_fX, l_fY, l_fZ);
    Set(::fabs(l_fX), ::fabs(l_fY), ::fabs(l_fZ));
    return (*this);
}

SICPPSDK_INLINE CVector3f& CVector3f::Absolute(const CVector3f& in_rCVec3)
{
    float l_fX, l_fY, l_fZ;
    in_rCVec3.Get(l_fX, l_fY, l_fZ);
    m_fX = ::fabs(l_fX);
    m_fY = ::fabs(l_fY);
    m_fZ = ::fabs(l_fZ);

    return (*this);
}

SICPPSDK_INLINE CVector3f& CVector3f::ClampInPlace(const float in_fMin, const float in_fMax)
{
    float l_fX, l_fY, l_fZ;

    Get( l_fX, l_fY, l_fZ );

    LimitValue( l_fX, in_fMin, in_fMax );
    LimitValue( l_fY, in_fMin, in_fMax );
    LimitValue( l_fZ, in_fMin, in_fMax );

    Set( l_fX, l_fY, l_fZ );

    return (*this);
}

};
};

#endif // __XSIVECTOR3F_H__