Vector2D.h

gehe zur Dokumentation dieser Datei

#ifndef _ZFXMATH_INCLUDE_VECTOR2D_H_
#define _ZFXMATH_INCLUDE_VECTOR2D_H_

namespace ZFXMath
{

    template<typename T>
    struct TVector3D;
    template<typename T>
    struct TVector4D;

    template<typename T>
    struct TVector2D
    {
        union
        {
            T           val[2];
            struct
            {
                T       x, y;
            };
            struct
            {
                T       u, v;
            };
        };

        TVector2D() {};

        TVector2D( const T& _x, const T& _y ) { x=_x; y=_y; }

        TVector2D( const T* pV ) { x = pV[0]; y = pV[1]; }
        TVector2D( const T& val ) { x = y = val; }
        TVector2D( const TVector2D& v ) { x = v.x; y = v.y; }
        TVector2D( const TVector3D<T>& v ) { x = v.x; y = v.y; }
        TVector2D( const TVector4D<T>& v ) { x = v.x; y = v.y; }


        operator T* ()  { return val; }
        operator const T* () const { return val; }

        T operator () ( const int i ) const
        {
            return val[ Check( i ) ];
        }

        T& operator () ( const int i )
        {
            return val[ Check( i ) ];
        }

        TVector2D& operator = ( const T& val ) { x = y = val; return *this; }
        TVector2D& operator += ( const TVector2D& v ) { x += v.x; y += v.y; return *this; }
        TVector2D& operator -= ( const TVector2D& v ) { x -= v.x; y -= v.y; return *this; }
        TVector2D& operator *= ( const TVector2D& v ) { x *= v.x; y *= v.y; return *this; }
        TVector2D& operator /= ( const TVector2D& v ) { x /= v.x; y /= v.y; return *this; }

        TVector2D& operator *= ( const T& v ) { x *= v; y *= v; return *this; }
        TVector2D& operator /= ( const T& v ) { x /= v; y /= v; return *this; }

        TVector2D operator + () const { return *this; }
        TVector2D operator - () const { return TVector2D( -x, -y ); }

        TVector2D operator + ( const TVector2D& v ) const { return TVector2D( x + v.x, y + v.y ); }
        TVector2D operator - ( const TVector2D& v ) const { return TVector2D( x - v.x, y - v.y ); }
        TVector2D operator * ( const TVector2D& v ) const { return TVector2D( x * v.x, y * v.y ); }
        TVector2D operator / ( const TVector2D& v ) const { return TVector2D( x / v.x, y / v.y ); }
        TVector2D operator * ( const T& v ) const { return TVector2D( x * v, y * v ); }
        TVector2D operator / ( const T& v ) const { return TVector2D( x / v, y / v ); }
        friend TVector2D<T> operator * ( const T& val, const TVector2D<T>& vec )
        { return (TVector2D) ( vec.x * val, vec.y * val ); }

        T LengthSqr()
        {
            return DotProduct( *this );
        };

        T Length()
        {
            return Sqrt( LengthSqr() );
        };

        void Normalize()
        {
            (*this) /= Length();
        };

        T DotProduct( const TVector2D& v ) const { return v.x * x + v.y * y; }
 
        TVector2D Reflect( const TVector2D& n ) const
        {
            return TVector2D( (*this) - 2 * DotProduct( n ) * n );
        }

        TVector2D Refract( const TVector2D& n, const T& ri ) const
        {
            return Interpolate( (*this), n, 1 - ri ).Normalize();
        }

    private:
        inline int Check( const int index ) const
        {
            // Check bounds in debug build
            assert( index >= 0 && index < 2 );

            return (index);
        }
    };
}

#endif //_ZFXMATH_INCLUDE_VECTOR2D_H_

---