Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

rect.h

Go to the documentation of this file.
00001 // Copyright (C) 2002-2010 Nikolaus Gebhardt
00002 // This file is part of the "Irrlicht Engine".
00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
00004 
00005 #ifndef __IRR_RECT_H_INCLUDED__
00006 #define __IRR_RECT_H_INCLUDED__
00007 
00008 #include "irrTypes.h"
00009 #include "dimension2d.h"
00010 #include "position2d.h"
00011 
00012 namespace irr
00013 {
00014 namespace core
00015 {
00016 
00018 
00025         template <class T>
00026         class rect
00027         {
00028         public:
00029 
00031                 rect() : UpperLeftCorner(0,0), LowerRightCorner(0,0) {}
00032 
00034                 rect(T x, T y, T x2, T y2)
00035                         : UpperLeftCorner(x,y), LowerRightCorner(x2,y2) {}
00036 
00038                 rect(const position2d<T>& upperLeft, const position2d<T>& lowerRight)
00039                         : UpperLeftCorner(upperLeft), LowerRightCorner(lowerRight) {}
00040 
00042                 template <class U>
00043                 rect(const position2d<T>& pos, const dimension2d<U>& size)
00044                         : UpperLeftCorner(pos), LowerRightCorner(pos.X + size.Width, pos.Y + size.Height) {}
00045 
00047                 rect<T> operator+(const position2d<T>& pos) const
00048                 {
00049                         rect<T> ret(*this);
00050                         return ret+=pos;
00051                 }
00052 
00054                 rect<T>& operator+=(const position2d<T>& pos)
00055                 {
00056                         UpperLeftCorner += pos;
00057                         LowerRightCorner += pos;
00058                         return *this;
00059                 }
00060 
00062                 rect<T> operator-(const position2d<T>& pos) const
00063                 {
00064                         rect<T> ret(*this);
00065                         return ret-=pos;
00066                 }
00067 
00069                 rect<T>& operator-=(const position2d<T>& pos)
00070                 {
00071                         UpperLeftCorner -= pos;
00072                         LowerRightCorner -= pos;
00073                         return *this;
00074                 }
00075 
00077                 bool operator==(const rect<T>& other) const
00078                 {
00079                         return (UpperLeftCorner == other.UpperLeftCorner &&
00080                                 LowerRightCorner == other.LowerRightCorner);
00081                 }
00082 
00084                 bool operator!=(const rect<T>& other) const
00085                 {
00086                         return (UpperLeftCorner != other.UpperLeftCorner ||
00087                                 LowerRightCorner != other.LowerRightCorner);
00088                 }
00089 
00091                 bool operator<(const rect<T>& other) const
00092                 {
00093                         return getArea() < other.getArea();
00094                 }
00095 
00097                 T getArea() const
00098                 {
00099                         return getWidth() * getHeight();
00100                 }
00101 
00103 
00105                 bool isPointInside(const position2d<T>& pos) const
00106                 {
00107                         return (UpperLeftCorner.X <= pos.X &&
00108                                 UpperLeftCorner.Y <= pos.Y &&
00109                                 LowerRightCorner.X >= pos.X &&
00110                                 LowerRightCorner.Y >= pos.Y);
00111                 }
00112 
00114 
00116                 bool isRectCollided(const rect<T>& other) const
00117                 {
00118                         return (LowerRightCorner.Y > other.UpperLeftCorner.Y &&
00119                                 UpperLeftCorner.Y < other.LowerRightCorner.Y &&
00120                                 LowerRightCorner.X > other.UpperLeftCorner.X &&
00121                                 UpperLeftCorner.X < other.LowerRightCorner.X);
00122                 }
00123 
00125 
00126                 void clipAgainst(const rect<T>& other)
00127                 {
00128                         if (other.LowerRightCorner.X < LowerRightCorner.X)
00129                                 LowerRightCorner.X = other.LowerRightCorner.X;
00130                         if (other.LowerRightCorner.Y < LowerRightCorner.Y)
00131                                 LowerRightCorner.Y = other.LowerRightCorner.Y;
00132 
00133                         if (other.UpperLeftCorner.X > UpperLeftCorner.X)
00134                                 UpperLeftCorner.X = other.UpperLeftCorner.X;
00135                         if (other.UpperLeftCorner.Y > UpperLeftCorner.Y)
00136                                 UpperLeftCorner.Y = other.UpperLeftCorner.Y;
00137 
00138                         // correct possible invalid rect resulting from clipping
00139                         if (UpperLeftCorner.Y > LowerRightCorner.Y)
00140                                 UpperLeftCorner.Y = LowerRightCorner.Y;
00141                         if (UpperLeftCorner.X > LowerRightCorner.X)
00142                                 UpperLeftCorner.X = LowerRightCorner.X;
00143                 }
00144 
00146 
00147                 bool constrainTo(const rect<T>& other)
00148                 {
00149                         if (other.getWidth() < getWidth() || other.getHeight() < getHeight())
00150                                 return false;
00151 
00152                         T diff = other.LowerRightCorner.X - LowerRightCorner.X;
00153                         if (diff < 0)
00154                         {
00155                                 LowerRightCorner.X += diff;
00156                                 UpperLeftCorner.X  += diff;
00157                         }
00158 
00159                         diff = other.LowerRightCorner.Y - LowerRightCorner.Y;
00160                         if (diff < 0)
00161                         {
00162                                 LowerRightCorner.Y += diff;
00163                                 UpperLeftCorner.Y  += diff;
00164                         }
00165 
00166                         diff = UpperLeftCorner.X - other.UpperLeftCorner.X;
00167                         if (diff < 0)
00168                         {
00169                                 UpperLeftCorner.X  -= diff;
00170                                 LowerRightCorner.X -= diff;
00171                         }
00172 
00173                         diff = UpperLeftCorner.Y - other.UpperLeftCorner.Y;
00174                         if (diff < 0)
00175                         {
00176                                 UpperLeftCorner.Y  -= diff;
00177                                 LowerRightCorner.Y -= diff;
00178                         }
00179 
00180                         return true;
00181                 }
00182 
00184                 T getWidth() const
00185                 {
00186                         return LowerRightCorner.X - UpperLeftCorner.X;
00187                 }
00188 
00190                 T getHeight() const
00191                 {
00192                         return LowerRightCorner.Y - UpperLeftCorner.Y;
00193                 }
00194 
00196                 void repair()
00197                 {
00198                         if (LowerRightCorner.X < UpperLeftCorner.X)
00199                         {
00200                                 T t = LowerRightCorner.X;
00201                                 LowerRightCorner.X = UpperLeftCorner.X;
00202                                 UpperLeftCorner.X = t;
00203                         }
00204 
00205                         if (LowerRightCorner.Y < UpperLeftCorner.Y)
00206                         {
00207                                 T t = LowerRightCorner.Y;
00208                                 LowerRightCorner.Y = UpperLeftCorner.Y;
00209                                 UpperLeftCorner.Y = t;
00210                         }
00211                 }
00212 
00214 
00216                 bool isValid() const
00217                 {
00218                         return ((LowerRightCorner.X >= UpperLeftCorner.X) &&
00219                                 (LowerRightCorner.Y >= UpperLeftCorner.Y));
00220                 }
00221 
00223                 position2d<T> getCenter() const
00224                 {
00225                         return position2d<T>(
00226                                         (UpperLeftCorner.X + LowerRightCorner.X) / 2,
00227                                         (UpperLeftCorner.Y + LowerRightCorner.Y) / 2);
00228                 }
00229 
00231                 dimension2d<T> getSize() const
00232                 {
00233                         return dimension2d<T>(getWidth(), getHeight());
00234                 }
00235 
00236 
00238 
00241                 void addInternalPoint(const position2d<T>& p)
00242                 {
00243                         addInternalPoint(p.X, p.Y);
00244                 }
00245 
00247 
00251                 void addInternalPoint(T x, T y)
00252                 {
00253                         if (x>LowerRightCorner.X)
00254                                 LowerRightCorner.X = x;
00255                         if (y>LowerRightCorner.Y)
00256                                 LowerRightCorner.Y = y;
00257 
00258                         if (x<UpperLeftCorner.X)
00259                                 UpperLeftCorner.X = x;
00260                         if (y<UpperLeftCorner.Y)
00261                                 UpperLeftCorner.Y = y;
00262                 }
00263 
00265                 position2d<T> UpperLeftCorner;
00267                 position2d<T> LowerRightCorner;
00268         };
00269 
00271         typedef rect<f32> rectf;
00273         typedef rect<s32> recti;
00274 
00275 } // end namespace core
00276 } // end namespace irr
00277 
00278 #endif
00279 

The Irrlicht Engine
The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Oct 24 12:41:58 2010 by Doxygen (1.6.2)