xsi_vector2f.h

Go to the documentation of this file.

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

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

#ifndef __XSIVECTOR2F_H__
#define __XSIVECTOR2F_H__

#include "sicppsdk.h"
#include <math.h>

namespace XSI {

namespace MATH {

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

        SICPPSDK_INLINE CVector2f(float in_X, float in_Y );

        SICPPSDK_INLINE CVector2f( const CVector2f& in_vector2);

        ~CVector2f() {}

        SICPPSDK_INLINE CVector2f & operator=( const CVector2f & in_vector2 );

        SICPPSDK_INLINE bool operator ==(const CVector2f & in_vector2 )const;

        SICPPSDK_INLINE bool operator !=(const CVector2f & in_vector2 )const;

        SICPPSDK_INLINE bool operator < ( const CVector2f & in_vector2 ) const;

        SICPPSDK_INLINE CVector2f& operator ~();

        SICPPSDK_INLINE CVector2f& operator +=(const CVector2f& in_vector2);

        SICPPSDK_INLINE CVector2f& operator -=(const CVector2f & in_vector2);

        SICPPSDK_INLINE CVector2f& operator *=(const float& in_dAlpha);

        SICPPSDK_INLINE CVector2f& SetNull();

        SICPPSDK_INLINE float GetLength()const;

        SICPPSDK_INLINE float GetLengthSquared()const;

        SICPPSDK_INLINE bool Equals(const CVector2f& in_vector2)const;

        SICPPSDK_INLINE bool EpsilonEquals
        (
                const CVector2f& in_vector,
                const float in_fEpsilon
        )const;

        SICPPSDK_INLINE CVector2f& ScaleAddInPlace(float in_dS,const CVector2f& in_vector2);

        SICPPSDK_INLINE CVector2f& ScaleAdd
        (
                float                           in_dS,
                const CVector2f&        in_vector3A,
                const CVector2f&        in_vector3B
        );

        SICPPSDK_INLINE CVector2f& ScaleInPlace(float in_dAlpha);

        SICPPSDK_INLINE CVector2f& Scale(float in_Alpha, const CVector2f& in_vector2);

        SICPPSDK_INLINE CVector2f& NegateInPlace();

        SICPPSDK_INLINE CVector2f& Negate(const CVector2f& in_vector2);

        SICPPSDK_INLINE CVector2f& SubInPlace(const CVector2f& in_vector2);

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

        SICPPSDK_INLINE CVector2f& AddInPlace(const CVector2f& in_vector2);

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

        SICPPSDK_INLINE float GetY()const;

        SICPPSDK_INLINE CVector2f& PutY(float in_X);

        SICPPSDK_INLINE float GetX()const;

        SICPPSDK_INLINE CVector2f& PutX(float in_X);

private:
        float m_X,m_Y;
};

//inline functions
SICPPSDK_INLINE CVector2f::CVector2f()
{
        m_X = 0;
        m_Y = 0;
}

SICPPSDK_INLINE CVector2f::CVector2f( const CVector2f& in_vct )
{
        *this = in_vct;
}

SICPPSDK_INLINE CVector2f::CVector2f(float in_X, float in_Y):m_X(in_X),m_Y(in_Y){}


SICPPSDK_INLINE CVector2f& CVector2f::operator=( const CVector2f & in_vct )
{
        m_X = in_vct.m_X;
        m_Y = in_vct.m_Y;
        return (*this);
}

SICPPSDK_INLINE bool CVector2f::operator ==(const CVector2f & in_vector2 )const
{
        return Equals(in_vector2);
}

SICPPSDK_INLINE bool CVector2f::operator !=(const CVector2f & in_vector2 )const
{
        return ! Equals(in_vector2);
}

SICPPSDK_INLINE bool CVector2f::operator < ( const CVector2f& in_vector2 ) const
{
        if ( m_X != in_vector2.m_X ) return m_X < in_vector2.m_X;
        if ( m_Y != in_vector2.m_Y ) return m_Y < in_vector2.m_Y;
        return false;
}

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

SICPPSDK_INLINE CVector2f& CVector2f::operator +=(const CVector2f& in_vector2)
{
        return AddInPlace(in_vector2);
}

SICPPSDK_INLINE CVector2f& CVector2f::operator -=(const CVector2f& in_vector2)
{
        return SubInPlace(in_vector2);
}

SICPPSDK_INLINE CVector2f& CVector2f::operator *=(const float& in_dAlpha)
{
        return ScaleInPlace(in_dAlpha);
}

SICPPSDK_INLINE CVector2f& CVector2f::SetNull()
{
        m_X = m_Y = 0.0;
        return (*this);
}

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

SICPPSDK_INLINE float CVector2f::GetLengthSquared()const
{
        return(m_X*m_X + m_Y*m_Y );
}

SICPPSDK_INLINE bool CVector2f::Equals(const CVector2f& in_vec)const
{
        return (this == &in_vec) ? true : ( ( m_X == in_vec.GetX() ) && ( m_Y == in_vec.GetY() ) );
}

SICPPSDK_INLINE bool CVector2f::EpsilonEquals
(
        const CVector2f& in_cVec2,
        const float in_fEpsilon
)const
{
        return (this == &in_cVec2) ? true :
                (       fabs( m_X - in_cVec2.GetX() ) < ::fabs(in_fEpsilon) &&
                        fabs( m_Y - in_cVec2.GetY() ) < ::fabs(in_fEpsilon)     );
}

SICPPSDK_INLINE CVector2f& CVector2f::ScaleAddInPlace
(
        float in_ScalingFactor,
        const CVector2f& in_vec
)
{
        ScaleInPlace(in_ScalingFactor);
        return AddInPlace(in_vec);
}

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

SICPPSDK_INLINE CVector2f& CVector2f::ScaleInPlace(float in_dScalingFactor)
{
        m_X *= in_dScalingFactor;
        m_Y *= in_dScalingFactor;
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::Scale
(
        float in_dScalingFactor,
        const CVector2f& in_vec
)
{
        m_X = in_vec.GetX() * in_dScalingFactor;
        m_Y = in_vec.GetY() * in_dScalingFactor;
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::NegateInPlace()
{
        m_X = -m_X;
        m_Y = -m_Y;
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::Negate(const CVector2f& in_vec )
{
        m_X = -in_vec.GetX();
        m_Y = -in_vec.GetY();
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::SubInPlace(const CVector2f& in_vec)
{
        m_X -= in_vec.GetX();
        m_Y -= in_vec.GetY();
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::Sub
(
        const CVector2f& in_vec3A,
        const CVector2f& in_vec3B
)
{
        m_X = in_vec3A.GetX() - in_vec3B.GetX();
        m_Y = in_vec3A.GetY() - in_vec3B.GetY();
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::AddInPlace(const CVector2f& in_vec)
{
        m_X += in_vec.GetX();
        m_Y += in_vec.GetY();
        return (*this);
}

SICPPSDK_INLINE CVector2f& CVector2f::Add
(
        const CVector2f& in_vec3A,
        const CVector2f& in_vec3B
)
{
        m_X = in_vec3A.GetX() + in_vec3B.GetX();
        m_Y = in_vec3A.GetY() + in_vec3B.GetY();
        return (*this);
}

SICPPSDK_INLINE float CVector2f::GetY()const
{
        return m_Y;
}

SICPPSDK_INLINE CVector2f& CVector2f::PutY(float in_Y)
{
        m_Y = in_Y;
        return (*this);
}

SICPPSDK_INLINE float CVector2f::GetX()const
{
        return m_X;
}

SICPPSDK_INLINE CVector2f& CVector2f::PutX(float in_X)
{
        m_X = in_X;
        return (*this);
}

};
};

#endif // __XSIVECTOR2F_H__