C:/Users/Marc/Desktop/Phystank/trunk/src/util/Vector2.h

//This file is part of PhysTank.
//
//PhysTank is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//PhysTank is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with PhysTank.  If not, see <http://www.gnu.org/licenses/>.
//
// © Marc Johnson, 2009

#ifndef _VECTOR2_
#define _VECTOR2_

#include <cmath>
#include <iostream>

class Vector2
{
public:
        float _x, _y, _unused; //Used for alignment purposes, that a contradiction ? :)

        Vector2()
        :_x(0), _y(0), _unused(0) 
        {
        }

        Vector2(float x, float y)
        :_x(x), _y(y), _unused(0)
        {
        }

        Vector2(const Vector2& v)
        :_x(v._x), _y(v._y), _unused(0)
        {
        }

        Vector2 operator+(const Vector2& v) const
        {
                Vector2 temp;

                temp._x = _x + v._x;
                temp._y = _y + v._y;

                return temp;
        }

        Vector2 operator+(const float fTranslation) const
        {
                Vector2 temp;

                temp._x += fTranslation;
                temp._y += fTranslation;

                return temp;
        }

        Vector2 operator-(const Vector2& v) const
        {
                Vector2 temp;

                temp._x = _x - v._x;
                temp._y = _y - v._y;

                return temp;
        }

        Vector2 operator-(const float fTranslation) const
        {
                Vector2 temp;

                temp._x -= fTranslation;
                temp._y -= fTranslation;

                return temp;
        }
        
        Vector2 operator*(const float fScale) const
        {
                Vector2 temp;

                temp._x *= fScale;
                temp._y *= fScale;

                return temp;
        }

        Vector2 operator-() const
        {
                Vector2 temp;

                temp._x = -_x;
                temp._y = -_y;

                return temp;
        }

        Vector2 Unit() const
        {
                Vector2 temp(*this);

                temp.Normalize();

                return temp;
        }

        Vector2 & operator+=(const Vector2& v) 
        {
                _x += v._x;
                _y += v._y;

                return *this;
        }

        Vector2 & operator+=(const float fTranslation)
        {
                _x += fTranslation;
                _y += fTranslation;

                return *this;
        }

        Vector2 & operator-=(const Vector2& v)
        {
                _x -= v._x;
                _y -= v._y;

                return *this;
        }

        Vector2 & operator-=(const float fTranslation)
        {
                _x -= fTranslation;
                _y -= fTranslation;

                return *this;
        }

        Vector2 & operator*=(const float fScale)
        {
                _x *= fScale;
                _y *= fScale;

                return *this;
        }

        Vector2 & operator=(const Vector2& v)
        {
                _x = v._x;
                _y = v._y;

                return *this;
        }

        Vector2 & SetX(const float x) 
        {
                _x = x;

                return *this;
        }

        Vector2 & SetY(const float y)
        {
                _y = y;

                return *this;
        }

        Vector2 & Set(const float x, const float y)
        {
                _x = x;
                _y = y;

                return *this;
        }

        Vector2 & Normalize()
        {
                float fLength = Length();

                _x /= fLength;
                _y /= fLength;

                return *this;
        }

        Vector2 & Reverse()
        {
                _x = -_x;
                _y = -_y;

                return *this;
        }

        float CrossZ(const Vector2& other) const
        {
                return _x * other._y + _y * other._x;
        }

        float Length() const
        {
                return std::sqrt(_x * _x + _y * _y);
        }

        float Dot(const Vector2& other) const
        {
                return _x * other._x + _y * other._y;
        }
};

static inline std::ostream& operator<<(std::ostream& os, const Vector2& v)
{
        os << v._x << " " << v._y;

        return os;
}

static inline std::istream& operator>>(std::istream& is, Vector2& v)
{
        is >> v._x >> v._y;

        return is;
}

#endif

---