rect.h

Go to the documentation of this file.

// Copyright (C) 2002-2011 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __IRR_RECT_H_INCLUDED__
#define __IRR_RECT_H_INCLUDED__

#include "irrTypes.h"
#include "dimension2d.h"
#include "position2d.h"

namespace irr
{
namespace core
{


        template <class T>
        class rect
        {
        public:

                rect() : UpperLeftCorner(0,0), LowerRightCorner(0,0) {}

                rect(T x, T y, T x2, T y2)
                        : UpperLeftCorner(x,y), LowerRightCorner(x2,y2) {}

                rect(const position2d<T>& upperLeft, const position2d<T>& lowerRight)
                        : UpperLeftCorner(upperLeft), LowerRightCorner(lowerRight) {}

                template <class U>
                rect(const position2d<T>& pos, const dimension2d<U>& size)
                        : UpperLeftCorner(pos), LowerRightCorner(pos.X + size.Width, pos.Y + size.Height) {}

                rect<T> operator+(const position2d<T>& pos) const
                {
                        rect<T> ret(*this);
                        return ret+=pos;
                }

                rect<T>& operator+=(const position2d<T>& pos)
                {
                        UpperLeftCorner += pos;
                        LowerRightCorner += pos;
                        return *this;
                }

                rect<T> operator-(const position2d<T>& pos) const
                {
                        rect<T> ret(*this);
                        return ret-=pos;
                }

                rect<T>& operator-=(const position2d<T>& pos)
                {
                        UpperLeftCorner -= pos;
                        LowerRightCorner -= pos;
                        return *this;
                }

                bool operator==(const rect<T>& other) const
                {
                        return (UpperLeftCorner == other.UpperLeftCorner &&
                                LowerRightCorner == other.LowerRightCorner);
                }

                bool operator!=(const rect<T>& other) const
                {
                        return (UpperLeftCorner != other.UpperLeftCorner ||
                                LowerRightCorner != other.LowerRightCorner);
                }

                bool operator<(const rect<T>& other) const
                {
                        return getArea() < other.getArea();
                }

                T getArea() const
                {
                        return getWidth() * getHeight();
                }


                bool isPointInside(const position2d<T>& pos) const
                {
                        return (UpperLeftCorner.X <= pos.X &&
                                UpperLeftCorner.Y <= pos.Y &&
                                LowerRightCorner.X >= pos.X &&
                                LowerRightCorner.Y >= pos.Y);
                }


                bool isRectCollided(const rect<T>& other) const
                {
                        return (LowerRightCorner.Y > other.UpperLeftCorner.Y &&
                                UpperLeftCorner.Y < other.LowerRightCorner.Y &&
                                LowerRightCorner.X > other.UpperLeftCorner.X &&
                                UpperLeftCorner.X < other.LowerRightCorner.X);
                }


                void clipAgainst(const rect<T>& other)
                {
                        if (other.LowerRightCorner.X < LowerRightCorner.X)
                                LowerRightCorner.X = other.LowerRightCorner.X;
                        if (other.LowerRightCorner.Y < LowerRightCorner.Y)
                                LowerRightCorner.Y = other.LowerRightCorner.Y;

                        if (other.UpperLeftCorner.X > UpperLeftCorner.X)
                                UpperLeftCorner.X = other.UpperLeftCorner.X;
                        if (other.UpperLeftCorner.Y > UpperLeftCorner.Y)
                                UpperLeftCorner.Y = other.UpperLeftCorner.Y;

                        // correct possible invalid rect resulting from clipping
                        if (UpperLeftCorner.Y > LowerRightCorner.Y)
                                UpperLeftCorner.Y = LowerRightCorner.Y;
                        if (UpperLeftCorner.X > LowerRightCorner.X)
                                UpperLeftCorner.X = LowerRightCorner.X;
                }


                bool constrainTo(const rect<T>& other)
                {
                        if (other.getWidth() < getWidth() || other.getHeight() < getHeight())
                                return false;

                        T diff = other.LowerRightCorner.X - LowerRightCorner.X;
                        if (diff < 0)
                        {
                                LowerRightCorner.X += diff;
                                UpperLeftCorner.X  += diff;
                        }

                        diff = other.LowerRightCorner.Y - LowerRightCorner.Y;
                        if (diff < 0)
                        {
                                LowerRightCorner.Y += diff;
                                UpperLeftCorner.Y  += diff;
                        }

                        diff = UpperLeftCorner.X - other.UpperLeftCorner.X;
                        if (diff < 0)
                        {
                                UpperLeftCorner.X  -= diff;
                                LowerRightCorner.X -= diff;
                        }

                        diff = UpperLeftCorner.Y - other.UpperLeftCorner.Y;
                        if (diff < 0)
                        {
                                UpperLeftCorner.Y  -= diff;
                                LowerRightCorner.Y -= diff;
                        }

                        return true;
                }

                T getWidth() const
                {
                        return LowerRightCorner.X - UpperLeftCorner.X;
                }

                T getHeight() const
                {
                        return LowerRightCorner.Y - UpperLeftCorner.Y;
                }

                void repair()
                {
                        if (LowerRightCorner.X < UpperLeftCorner.X)
                        {
                                T t = LowerRightCorner.X;
                                LowerRightCorner.X = UpperLeftCorner.X;
                                UpperLeftCorner.X = t;
                        }

                        if (LowerRightCorner.Y < UpperLeftCorner.Y)
                        {
                                T t = LowerRightCorner.Y;
                                LowerRightCorner.Y = UpperLeftCorner.Y;
                                UpperLeftCorner.Y = t;
                        }
                }


                bool isValid() const
                {
                        return ((LowerRightCorner.X >= UpperLeftCorner.X) &&
                                (LowerRightCorner.Y >= UpperLeftCorner.Y));
                }

                position2d<T> getCenter() const
                {
                        return position2d<T>(
                                        (UpperLeftCorner.X + LowerRightCorner.X) / 2,
                                        (UpperLeftCorner.Y + LowerRightCorner.Y) / 2);
                }

                dimension2d<T> getSize() const
                {
                        return dimension2d<T>(getWidth(), getHeight());
                }



                void addInternalPoint(const position2d<T>& p)
                {
                        addInternalPoint(p.X, p.Y);
                }


                void addInternalPoint(T x, T y)
                {
                        if (x>LowerRightCorner.X)
                                LowerRightCorner.X = x;
                        if (y>LowerRightCorner.Y)
                                LowerRightCorner.Y = y;

                        if (x<UpperLeftCorner.X)
                                UpperLeftCorner.X = x;
                        if (y<UpperLeftCorner.Y)
                                UpperLeftCorner.Y = y;
                }

                position2d<T> UpperLeftCorner;
                position2d<T> LowerRightCorner;
        };

        typedef rect<f32> rectf;
        typedef rect<s32> recti;

} // end namespace core
} // end namespace irr

#endif