irr::core::rect< T > Class Template Reference

Rectangle template. More...

#include <rect.h>

Public Member Functions
	rect ()
	Default constructor creating empty rectangle at (0,0) More...
	rect (T x, T y, T x2, T y2)
	Constructor with two corners. More...
	rect (const position2d< T > &upperLeft, const position2d< T > &lowerRight)
	Constructor with two corners. More...
template<class U >
	rect (const position2d< T > &pos, const dimension2d< U > &size)
	Constructor with upper left corner and dimension. More...
template<class U >
	rect (const dimension2d< U > &size)
	Constructor with upper left at 0,0 and lower right using dimension. More...
rect< T >	operator+ (const position2d< T > &pos) const
	move right by given numbers More...
rect< T > &	operator+= (const position2d< T > &pos)
	move right by given numbers More...
rect< T >	operator- (const position2d< T > &pos) const
	move left by given numbers More...
rect< T > &	operator-= (const position2d< T > &pos)
	move left by given numbers More...
bool	operator== (const rect< T > &other) const
	equality operator More...
bool	operator!= (const rect< T > &other) const
	inequality operator More...
bool	operator< (const rect< T > &other) const
	compares size of rectangles More...
T	getArea () const
	Returns size of rectangle. More...
bool	isPointInside (const position2d< T > &pos) const
	Returns if a 2d point is within this rectangle. More...
bool	isRectCollided (const rect< T > &other) const
	Check if the rectangle collides with another rectangle. More...
void	clipAgainst (const rect< T > &other)
	Clips this rectangle with another one. More...
bool	constrainTo (const rect< T > &other)
	Moves this rectangle to fit inside another one. More...
T	getWidth () const
	Get width of rectangle. More...
T	getHeight () const
	Get height of rectangle. More...
void	repair ()
	If the lower right corner of the rect is smaller then the upper left, the points are swapped. More...
bool	isValid () const
	Returns if the rect is valid to draw. More...
position2d< T >	getCenter () const
	Get the center of the rectangle. More...
dimension2d< T >	getSize () const
	Get the dimensions of the rectangle. More...
void	addInternalPoint (const position2d< T > &p)
	Adds a point to the rectangle. More...
void	addInternalPoint (T x, T y)
	Adds a point to the bounding rectangle. More...

Public Attributes
position2d< T >	UpperLeftCorner
	Upper left corner. More...
position2d< T >	LowerRightCorner
	Lower right corner. More...

Detailed Description

template<class T>
class irr::core::rect< T >

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.

Definition at line 26 of file rect.h.

Constructor & Destructor Documentation

rect() [1/5]

template<class T>

irr::core::rect< T >::rect ( )

inline

Default constructor creating empty rectangle at (0,0)

Definition at line 31 of file rect.h.

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

rect() [2/5]

template<class T>

irr::core::rect< T >::rect ( T  x, T  y, T  x2, T  y2  )

inline

Constructor with two corners.

Definition at line 34 of file rect.h.

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

rect() [3/5]

template<class T>

irr::core::rect< T >::rect ( const position2d< T > &  upperLeft, const position2d< T > &  lowerRight  )

inline

Constructor with two corners.

Definition at line 38 of file rect.h.

                        : UpperLeftCorner(upperLeft), LowerRightCorner(lowerRight) {}

rect() [4/5]

template<class T>

template<class U >

irr::core::rect< T >::rect ( const position2d< T > &  pos, const dimension2d< U > &  size  )

inline

Constructor with upper left corner and dimension.

Definition at line 43 of file rect.h.

                        : UpperLeftCorner(pos), LowerRightCorner(pos.X + size.Width, pos.Y + size.Height) {}

rect() [5/5]

template<class T>

template<class U >

irr::core::rect< T >::rect ( const dimension2d< U > &  size )

inlineexplicit

Constructor with upper left at 0,0 and lower right using dimension.

Definition at line 48 of file rect.h.

                        : UpperLeftCorner(0,0), LowerRightCorner(size.Width, size.Height) {}

Member Function Documentation

addInternalPoint() [1/2]

template<class T>

void irr::core::rect< T >::addInternalPoint ( const position2d< T > &  p )

inline

Adds a point to the rectangle.

Causes the rectangle to grow bigger if point is outside of the box

Parameters

p	Point to add to the box.

Definition at line 246 of file rect.h.

                {
                        addInternalPoint(p.X, p.Y);
                }

addInternalPoint() [2/2]

template<class T>

void irr::core::rect< T >::addInternalPoint ( T  x, T  y  )

inline

Adds a point to the bounding rectangle.

Causes the rectangle to grow bigger if point is outside of the box

Parameters

x	X-Coordinate of the point to add to this box.
y	Y-Coordinate of the point to add to this box.

Definition at line 256 of file rect.h.

                {
                        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;
                }

clipAgainst()

template<class T>

void irr::core::rect< T >::clipAgainst ( const rect< T > &  other )

inline

Clips this rectangle with another one.

Parameters

other

Rectangle to clip with

Definition at line 131 of file rect.h.

                {
                        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;
                }

constrainTo()

template<class T>

bool irr::core::rect< T >::constrainTo ( const rect< T > &  other )

inline

Moves this rectangle to fit inside another one.

Returns

True on success, false if not possible

Definition at line 152 of file rect.h.

                {
                        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;
                }

getArea()

template<class T>

T irr::core::rect< T >::getArea ( ) const

inline

Returns size of rectangle.

Definition at line 102 of file rect.h.

                {
                        return getWidth() * getHeight();
                }

getCenter()

template<class T>

position2d<T> irr::core::rect< T >::getCenter ( ) const

inline

Get the center of the rectangle.

Definition at line 228 of file rect.h.

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

getHeight()

template<class T>

T irr::core::rect< T >::getHeight ( ) const

inline

Get height of rectangle.

Definition at line 195 of file rect.h.

                {
                        return LowerRightCorner.Y - UpperLeftCorner.Y;
                }

getSize()

template<class T>

dimension2d<T> irr::core::rect< T >::getSize ( ) const

inline

Get the dimensions of the rectangle.

Definition at line 236 of file rect.h.

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

getWidth()

template<class T>

T irr::core::rect< T >::getWidth ( ) const

inline

Get width of rectangle.

Definition at line 189 of file rect.h.

                {
                        return LowerRightCorner.X - UpperLeftCorner.X;
                }

isPointInside()

template<class T>

bool irr::core::rect< T >::isPointInside ( const position2d< T > &  pos ) const

inline

Returns if a 2d point is within this rectangle.

Parameters

pos	Position to test if it lies within this rectangle.

Returns

True if the position is within the rectangle, false if not.

Definition at line 110 of file rect.h.

                {
                        return (UpperLeftCorner.X <= pos.X &&
                                UpperLeftCorner.Y <= pos.Y &&
                                LowerRightCorner.X >= pos.X &&
                                LowerRightCorner.Y >= pos.Y);
                }

isRectCollided()

template<class T>

bool irr::core::rect< T >::isRectCollided ( const rect< T > &  other ) const

inline

Check if the rectangle collides with another rectangle.

Parameters

other

Rectangle to test collision with

Returns

True if the rectangles collide.

Definition at line 121 of file rect.h.

                {
                        return (LowerRightCorner.Y > other.UpperLeftCorner.Y &&
                                UpperLeftCorner.Y < other.LowerRightCorner.Y &&
                                LowerRightCorner.X > other.UpperLeftCorner.X &&
                                UpperLeftCorner.X < other.LowerRightCorner.X);
                }

isValid()

template<class T>

bool irr::core::rect< T >::isValid ( ) const

inline

Returns if the rect is valid to draw.

It would be invalid if the UpperLeftCorner is lower or more right than the LowerRightCorner.

Definition at line 221 of file rect.h.

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

operator!=()

template<class T>

bool irr::core::rect< T >::operator!= ( const rect< T > &  other ) const

inline

inequality operator

Definition at line 89 of file rect.h.

                {
                        return (UpperLeftCorner != other.UpperLeftCorner ||
                                LowerRightCorner != other.LowerRightCorner);
                }

operator+()

template<class T>

rect<T> irr::core::rect< T >::operator+ ( const position2d< T > &  pos ) const

inline

move right by given numbers

Definition at line 52 of file rect.h.

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

operator+=()

template<class T>

rect<T>& irr::core::rect< T >::operator+= ( const position2d< T > &  pos )

inline

move right by given numbers

Definition at line 59 of file rect.h.

                {
                        UpperLeftCorner += pos;
                        LowerRightCorner += pos;
                        return *this;
                }

operator-()

template<class T>

rect<T> irr::core::rect< T >::operator- ( const position2d< T > &  pos ) const

inline

move left by given numbers

Definition at line 67 of file rect.h.

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

operator-=()

template<class T>

rect<T>& irr::core::rect< T >::operator-= ( const position2d< T > &  pos )

inline

move left by given numbers

Definition at line 74 of file rect.h.

                {
                        UpperLeftCorner -= pos;
                        LowerRightCorner -= pos;
                        return *this;
                }

operator<()

template<class T>

bool irr::core::rect< T >::operator< ( const rect< T > &  other ) const

inline

compares size of rectangles

Definition at line 96 of file rect.h.

                {
                        return getArea() < other.getArea();
                }

operator==()

template<class T>

bool irr::core::rect< T >::operator== ( const rect< T > &  other ) const

inline

equality operator

Definition at line 82 of file rect.h.

                {
                        return (UpperLeftCorner == other.UpperLeftCorner &&
                                LowerRightCorner == other.LowerRightCorner);
                }

repair()

template<class T>

void irr::core::rect< T >::repair ( )

inline

If the lower right corner of the rect is smaller then the upper left, the points are swapped.

Definition at line 201 of file rect.h.

                {
                        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;
                        }
                }

Member Data Documentation

LowerRightCorner

template<class T>

position2d<T> irr::core::rect< T >::LowerRightCorner

Lower right corner.

Definition at line 272 of file rect.h.

UpperLeftCorner

template<class T>

position2d<T> irr::core::rect< T >::UpperLeftCorner

Upper left corner.

Definition at line 270 of file rect.h.

---

The documentation for this class was generated from the following file:

• include/irrlicht/rect.h