C:/Users/Marc/Desktop/Phystank/trunk/src/util/Rect.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 _RECTANGLE_
#define _RECTANGLE_

#include <iostream>

class Rect
{
public:
        float _x;
        float _y;
        float _w;
        float _h;

        Rect()
        :_x(0), _y(0), _w(0), _h(0)
        {
        }

        Rect(const float x, const float y, const float w, const float h)
        :_x(x), _y(y), _w(w), _h(h)
        {
        }

        Rect(const Rect& r)
        :_x(r._x), _y(r._y), _w(r._w), _h(r._h)
        {
        }

        Rect & SetXY(const float x, const float y)
        {
                _x = x;
                _y = y;

                return *this;
        }

        Rect & SetWH(const float w, const float h)
        {
                _w = w;
                _h = h;

                return *this;
        }

        Rect & operator=(const Rect& r)
        {
                _x = r._x;
                _y = r._y;
                _w = r._w;
                _h = r._h;

                return *this;
        }

        Rect & Clip(const Rect& r)
        {
                if(_x < r._x)
                        _x = r._x;

                if(_y < r._y)
                        _y = r._y;

                if(Right() > r.Right())
                        _w = r.Right() - _x;

                if(Bottom() > r.Bottom())
                        _h = r.Bottom() - _y;

                return *this;
        }


        Rect GetClipped(const Rect& r) const
        {
                Rect temp(*this);

                return temp.Clip(r);
        }

        bool Intersects(const Rect& r) const
        {
                if(Right() < r.Left() || Left() > r.Right() || Top() > r.Bottom() || Bottom() < r.Top())
                        return true;

                return false;
        }

        bool PointInRect(const float x, const float y) const
        {
                if(x < Left() || x > Right() || y < Top() || y > Bottom())
                        return false;

                return true;
        }

        float Left() const
        {
                return _x;
        }

        float Top() const
        {
                return _y;
        }

        float Right() const
        {
                return _x + _w;
        }

        float Bottom() const
        {
                return _y + _h;
        }

};

inline std::ostream & operator<<(std::ostream & os, const Rect & rect)
{
        os << rect._x << " " << rect._y << " " << rect._w << " " << rect._h << " ";

        return os;
}

inline std::istream & operator>>(std::istream & is, Rect & rect)
{
        is >> rect._x >> rect._y >> rect._w >> rect._h;

        return is;
}

#endif

---