1 files changed, 279 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/include/rect.h b/src/others/irrlicht-1.8.1/include/rect.h
new file mode 100644
index 0000000..3f3883e
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/include/rect.h
@@ -0,0 +1,279 @@
+// Copyright (C) 2002-2012 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
+{
+        //! Rectangle template.
+        /** Mostly used by 2D GUI elements and for 2D drawing methods.
+        It has 2 positions instead of position and dimension and a fast
+        method for collision detection with other rectangles and points.
+        Coordinates are (0,0) for top-left corner, and increasing to the right
+        and to the bottom.
+        */
+        template <class T>
+        class rect
+        {
+        public:
+                //! Default constructor creating empty rectangle at (0,0)
+                rect() : UpperLeftCorner(0,0), LowerRightCorner(0,0) {}
+                //! Constructor with two corners
+                rect(T x, T y, T x2, T y2)
+                        : UpperLeftCorner(x,y), LowerRightCorner(x2,y2) {}
+                //! Constructor with two corners
+                rect(const position2d<T>& upperLeft, const position2d<T>& lowerRight)
+                        : UpperLeftCorner(upperLeft), LowerRightCorner(lowerRight) {}
+                //! Constructor with upper left corner and dimension
+                template <class U>
+                rect(const position2d<T>& pos, const dimension2d<U>& size)
+                        : UpperLeftCorner(pos), LowerRightCorner(pos.X + size.Width, pos.Y + size.Height) {}
+                //! move right by given numbers
+                rect<T> operator+(const position2d<T>& pos) const
+                {
+                        rect<T> ret(*this);
+                        return ret+=pos;
+                }
+                //! move right by given numbers
+                rect<T>& operator+=(const position2d<T>& pos)
+                {
+                        UpperLeftCorner += pos;
+                        LowerRightCorner += pos;
+                        return *this;
+                }
+                //! move left by given numbers
+                rect<T> operator-(const position2d<T>& pos) const
+                {
+                        rect<T> ret(*this);
+                        return ret-=pos;
+                }
+                //! move left by given numbers
+                rect<T>& operator-=(const position2d<T>& pos)
+                {
+                        UpperLeftCorner -= pos;
+                        LowerRightCorner -= pos;
+                        return *this;
+                }
+                //! equality operator
+                bool operator==(const rect<T>& other) const
+                {
+                        return (UpperLeftCorner == other.UpperLeftCorner &&
+                                LowerRightCorner == other.LowerRightCorner);
+                }
+                //! inequality operator
+                bool operator!=(const rect<T>& other) const
+                {
+                        return (UpperLeftCorner != other.UpperLeftCorner ||
+                                LowerRightCorner != other.LowerRightCorner);
+                }
+                //! compares size of rectangles
+                bool operator<(const rect<T>& other) const
+                {
+                        return getArea() < other.getArea();
+                }
+                //! Returns size of rectangle
+                T getArea() const
+                {
+                        return getWidth() * getHeight();
+                }
+                //! Returns if a 2d point is within this rectangle.
+                /** \param pos Position to test if it lies within this rectangle.
+                \return True if the position is within the rectangle, false if not. */
+                bool isPointInside(const position2d<T>& pos) const
+                {
+                        return (UpperLeftCorner.X <= pos.X &&
+                                UpperLeftCorner.Y <= pos.Y &&
+                                LowerRightCorner.X >= pos.X &&
+                                LowerRightCorner.Y >= pos.Y);
+                }
+                //! Check if the rectangle collides with another rectangle.
+                /** \param other Rectangle to test collision with
+                \return True if the rectangles collide. */
+                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);
+                }
+                //! Clips this rectangle with another one.
+                /** \param other Rectangle to clip with */
+                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;
+                }
+                //! Moves this rectangle to fit inside another one.
+                /** \return True on success, false if not possible */
+                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;
+                }
+                //! Get width of rectangle.
+                T getWidth() const
+                {
+                        return LowerRightCorner.X - UpperLeftCorner.X;
+                }
+                //! Get height of rectangle.
+                T getHeight() const
+                {
+                        return LowerRightCorner.Y - UpperLeftCorner.Y;
+                }
+                //! If the lower right corner of the rect is smaller then the upper left, the points are swapped.
+                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;
+                        }
+                }
+                //! Returns if the rect is valid to draw.
+                /** It would be invalid if the UpperLeftCorner is lower or more
+                right than the LowerRightCorner. */
+                bool isValid() const
+                {
+                        return ((LowerRightCorner.X >= UpperLeftCorner.X) &&
+                                (LowerRightCorner.Y >= UpperLeftCorner.Y));
+                }
+                //! Get the center of the rectangle
+                position2d<T> getCenter() const
+                {
+                        return position2d<T>(
+                                        (UpperLeftCorner.X + LowerRightCorner.X) / 2,
+                                        (UpperLeftCorner.Y + LowerRightCorner.Y) / 2);
+                }
+                //! Get the dimensions of the rectangle
+                dimension2d<T> getSize() const
+                {
+                        return dimension2d<T>(getWidth(), getHeight());
+                }
+                //! Adds a point to the rectangle
+                /** Causes the rectangle to grow bigger if point is outside of
+                the box
+                \param p Point to add to the box. */
+                void addInternalPoint(const position2d<T>& p)
+                {
+                        addInternalPoint(p.X, p.Y);
+                }
+                //! Adds a point to the bounding rectangle
+                /** Causes the rectangle to grow bigger if point is outside of
+                the box
+                \param x X-Coordinate of the point to add to this box.
+                \param y Y-Coordinate of the point to add to this box. */
+                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;
+                }
+                //! Upper left corner
+                position2d<T> UpperLeftCorner;
+                //! Lower right corner
+                position2d<T> LowerRightCorner;
+        };
+        //! Rectangle with float values
+        typedef rect<f32> rectf;
+        //! Rectangle with int values
+        typedef rect<s32> recti;
+} // end namespace core
+} // end namespace irr
+#endif

diff --git a/src/others/irrlicht-1.8.1/include/rect.h b/src/others/irrlicht-1.8.1/include/rect.h new file mode 100644 index 0000000..3f3883e --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/rect.h
@@ -0,0 +1,279 @@
	1	// Copyright (C) 2002-2012 Nikolaus Gebhardt
	2	// This file is part of the "Irrlicht Engine".
	3	// For conditions of distribution and use, see copyright notice in irrlicht.h
	4
	5	#ifndef __IRR_RECT_H_INCLUDED__
	6	#define __IRR_RECT_H_INCLUDED__
	7
	8	#include "irrTypes.h"
	9	#include "dimension2d.h"
	10	#include "position2d.h"
	11
	12	namespace irr
	13	{
	14	namespace core
	15	{
	16
	17	//! Rectangle template.
	18	/** Mostly used by 2D GUI elements and for 2D drawing methods.
	19	It has 2 positions instead of position and dimension and a fast
	20	method for collision detection with other rectangles and points.
	21
	22	Coordinates are (0,0) for top-left corner, and increasing to the right
	23	and to the bottom.
	24	*/
	25	template <class T>
	26	class rect
	27	{
	28	public:
	29
	30	//! Default constructor creating empty rectangle at (0,0)
	31	rect() : UpperLeftCorner(0,0), LowerRightCorner(0,0) {}
	32
	33	//! Constructor with two corners
	34	rect(T x, T y, T x2, T y2)
	35	: UpperLeftCorner(x,y), LowerRightCorner(x2,y2) {}
	36
	37	//! Constructor with two corners
	38	rect(const position2d<T>& upperLeft, const position2d<T>& lowerRight)
	39	: UpperLeftCorner(upperLeft), LowerRightCorner(lowerRight) {}
	40
	41	//! Constructor with upper left corner and dimension
	42	template <class U>
	43	rect(const position2d<T>& pos, const dimension2d<U>& size)
	44	: UpperLeftCorner(pos), LowerRightCorner(pos.X + size.Width, pos.Y + size.Height) {}
	45
	46	//! move right by given numbers
	47	rect<T> operator+(const position2d<T>& pos) const
	48	{
	49	rect<T> ret(*this);
	50	return ret+=pos;
	51	}
	52
	53	//! move right by given numbers
	54	rect<T>& operator+=(const position2d<T>& pos)
	55	{
	56	UpperLeftCorner += pos;
	57	LowerRightCorner += pos;
	58	return *this;
	59	}
	60
	61	//! move left by given numbers
	62	rect<T> operator-(const position2d<T>& pos) const
	63	{
	64	rect<T> ret(*this);
	65	return ret-=pos;
	66	}
	67
	68	//! move left by given numbers
	69	rect<T>& operator-=(const position2d<T>& pos)
	70	{
	71	UpperLeftCorner -= pos;
	72	LowerRightCorner -= pos;
	73	return *this;
	74	}
	75
	76	//! equality operator
	77	bool operator==(const rect<T>& other) const
	78	{
	79	return (UpperLeftCorner == other.UpperLeftCorner &&
	80	LowerRightCorner == other.LowerRightCorner);
	81	}
	82
	83	//! inequality operator
	84	bool operator!=(const rect<T>& other) const
	85	{
	86	return (UpperLeftCorner != other.UpperLeftCorner \|\|
	87	LowerRightCorner != other.LowerRightCorner);
	88	}
	89
	90	//! compares size of rectangles
	91	bool operator<(const rect<T>& other) const
	92	{
	93	return getArea() < other.getArea();
	94	}
	95
	96	//! Returns size of rectangle
	97	T getArea() const
	98	{
	99	return getWidth() * getHeight();
	100	}
	101
	102	//! Returns if a 2d point is within this rectangle.
	103	/** \param pos Position to test if it lies within this rectangle.
	104	\return True if the position is within the rectangle, false if not. */
	105	bool isPointInside(const position2d<T>& pos) const
	106	{
	107	return (UpperLeftCorner.X <= pos.X &&
	108	UpperLeftCorner.Y <= pos.Y &&
	109	LowerRightCorner.X >= pos.X &&
	110	LowerRightCorner.Y >= pos.Y);
	111	}
	112
	113	//! Check if the rectangle collides with another rectangle.
	114	/** \param other Rectangle to test collision with
	115	\return True if the rectangles collide. */
	116	bool isRectCollided(const rect<T>& other) const
	117	{
	118	return (LowerRightCorner.Y > other.UpperLeftCorner.Y &&
	119	UpperLeftCorner.Y < other.LowerRightCorner.Y &&
	120	LowerRightCorner.X > other.UpperLeftCorner.X &&
	121	UpperLeftCorner.X < other.LowerRightCorner.X);
	122	}
	123
	124	//! Clips this rectangle with another one.
	125	/** \param other Rectangle to clip with */
	126	void clipAgainst(const rect<T>& other)
	127	{
	128	if (other.LowerRightCorner.X < LowerRightCorner.X)
	129	LowerRightCorner.X = other.LowerRightCorner.X;
	130	if (other.LowerRightCorner.Y < LowerRightCorner.Y)
	131	LowerRightCorner.Y = other.LowerRightCorner.Y;
	132
	133	if (other.UpperLeftCorner.X > UpperLeftCorner.X)
	134	UpperLeftCorner.X = other.UpperLeftCorner.X;
	135	if (other.UpperLeftCorner.Y > UpperLeftCorner.Y)
	136	UpperLeftCorner.Y = other.UpperLeftCorner.Y;
	137
	138	// correct possible invalid rect resulting from clipping
	139	if (UpperLeftCorner.Y > LowerRightCorner.Y)
	140	UpperLeftCorner.Y = LowerRightCorner.Y;
	141	if (UpperLeftCorner.X > LowerRightCorner.X)
	142	UpperLeftCorner.X = LowerRightCorner.X;
	143	}
	144
	145	//! Moves this rectangle to fit inside another one.
	146	/** \return True on success, false if not possible */
	147	bool constrainTo(const rect<T>& other)
	148	{
	149	if (other.getWidth() < getWidth() \|\| other.getHeight() < getHeight())
	150	return false;
	151
	152	T diff = other.LowerRightCorner.X - LowerRightCorner.X;
	153	if (diff < 0)
	154	{
	155	LowerRightCorner.X += diff;
	156	UpperLeftCorner.X += diff;
	157	}
	158
	159	diff = other.LowerRightCorner.Y - LowerRightCorner.Y;
	160	if (diff < 0)
	161	{
	162	LowerRightCorner.Y += diff;
	163	UpperLeftCorner.Y += diff;
	164	}
	165
	166	diff = UpperLeftCorner.X - other.UpperLeftCorner.X;
	167	if (diff < 0)
	168	{
	169	UpperLeftCorner.X -= diff;
	170	LowerRightCorner.X -= diff;
	171	}
	172
	173	diff = UpperLeftCorner.Y - other.UpperLeftCorner.Y;
	174	if (diff < 0)
	175	{
	176	UpperLeftCorner.Y -= diff;
	177	LowerRightCorner.Y -= diff;
	178	}
	179
	180	return true;
	181	}
	182
	183	//! Get width of rectangle.
	184	T getWidth() const
	185	{
	186	return LowerRightCorner.X - UpperLeftCorner.X;
	187	}
	188
	189	//! Get height of rectangle.
	190	T getHeight() const
	191	{
	192	return LowerRightCorner.Y - UpperLeftCorner.Y;
	193	}
	194
	195	//! If the lower right corner of the rect is smaller then the upper left, the points are swapped.
	196	void repair()
	197	{
	198	if (LowerRightCorner.X < UpperLeftCorner.X)
	199	{
	200	T t = LowerRightCorner.X;
	201	LowerRightCorner.X = UpperLeftCorner.X;
	202	UpperLeftCorner.X = t;
	203	}
	204
	205	if (LowerRightCorner.Y < UpperLeftCorner.Y)
	206	{
	207	T t = LowerRightCorner.Y;
	208	LowerRightCorner.Y = UpperLeftCorner.Y;
	209	UpperLeftCorner.Y = t;
	210	}
	211	}
	212
	213	//! Returns if the rect is valid to draw.
	214	/** It would be invalid if the UpperLeftCorner is lower or more
	215	right than the LowerRightCorner. */
	216	bool isValid() const
	217	{
	218	return ((LowerRightCorner.X >= UpperLeftCorner.X) &&
	219	(LowerRightCorner.Y >= UpperLeftCorner.Y));
	220	}
	221
	222	//! Get the center of the rectangle
	223	position2d<T> getCenter() const
	224	{
	225	return position2d<T>(
	226	(UpperLeftCorner.X + LowerRightCorner.X) / 2,
	227	(UpperLeftCorner.Y + LowerRightCorner.Y) / 2);
	228	}
	229
	230	//! Get the dimensions of the rectangle
	231	dimension2d<T> getSize() const
	232	{
	233	return dimension2d<T>(getWidth(), getHeight());
	234	}
	235
	236
	237	//! Adds a point to the rectangle
	238	/** Causes the rectangle to grow bigger if point is outside of
	239	the box
	240	\param p Point to add to the box. */
	241	void addInternalPoint(const position2d<T>& p)
	242	{
	243	addInternalPoint(p.X, p.Y);
	244	}
	245
	246	//! Adds a point to the bounding rectangle
	247	/** Causes the rectangle to grow bigger if point is outside of
	248	the box
	249	\param x X-Coordinate of the point to add to this box.
	250	\param y Y-Coordinate of the point to add to this box. */
	251	void addInternalPoint(T x, T y)
	252	{
	253	if (x>LowerRightCorner.X)
	254	LowerRightCorner.X = x;
	255	if (y>LowerRightCorner.Y)
	256	LowerRightCorner.Y = y;
	257
	258	if (x<UpperLeftCorner.X)
	259	UpperLeftCorner.X = x;
	260	if (y<UpperLeftCorner.Y)
	261	UpperLeftCorner.Y = y;
	262	}
	263
	264	//! Upper left corner
	265	position2d<T> UpperLeftCorner;
	266	//! Lower right corner
	267	position2d<T> LowerRightCorner;
	268	};
	269
	270	//! Rectangle with float values
	271	typedef rect<f32> rectf;
	272	//! Rectangle with int values
	273	typedef rect<s32> recti;
	274
	275	} // end namespace core
	276	} // end namespace irr
	277
	278	#endif
	279