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__