std::math::rectangle< T > Template-Klassenreferenz

#include <rectangle.hpp>

Klassendiagramm für std::math::rectangle< T >:

Zusammengehörigkeiten von std::math::rectangle< T >:

Öffentliche Typen
typedef typedef T	value_type
typedef rectangle< T >	self_type
typedef T *	pointer

Öffentliche Methoden
virtual std::string	to_string ()
	rectangle ()
	rectangle (value_type _x, value_type _y, value_type _w, value_type _h)
	rectangle (vector2< value_type > pos, vector2< value_type > size)
const value_type &	top ()
void	top (const value_type &t)
const value_type &	left ()
void	left (const value_type &t)
const value_type &	bottom ()
const value_type &	right ()
vector2< value_type >	center ()
vector2< value_type >	size ()
rectangle< value_type >	inflate (value_type leftRight, value_type topBottom)
bool	contains (rectangle< T > r)
rectangle< value_type > &	intersect (const rectangle< value_type > &r1, const rectangle< value_type > &r2)
bool	intersects (const rectangle< value_type > &r)
void	offset (float offx, float offy)

Öffentliche Attribute
union {
struct {
value_type   x
value_type   y
value_type   width
value_type   height
}
struct {
vector2< T >   position
vector2< T >   size
}
value_type   c [4]
};

Ausführliche Beschreibung

template<typename T>
class std::math::rectangle< T >

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T >

typedef T* std::math::rectangle< T >::pointer

self_type

template<typename T >

typedef rectangle<T> std::math::rectangle< T >::self_type

value_type

template<typename T >

typedef typedef T std::math::rectangle< T >::value_type

Beschreibung der Konstruktoren und Destruktoren

rectangle() [1/3]

template<typename T >

std::math::rectangle< T >::rectangle ( )

inline

                : x(0), y(0), width(1), height(1) { }

rectangle() [2/3]

template<typename T >

std::math::rectangle< T >::rectangle ( value_type  _x, value_type  _y, value_type  _w, value_type  _h  )

inline

                : x(_x), y(_y), width(_w), height(_h) { }

rectangle() [3/3]

template<typename T >

std::math::rectangle< T >::rectangle ( vector2< value_type >  pos, vector2< value_type >  size  )

inline

                : x(pos.x), y(pos.y), width(size.x), height(size.y) { }

Dokumentation der Elementfunktionen

bottom()

template<typename T >

const value_type& std::math::rectangle< T >::bottom ( )

inline

{ return y + height; }

center()

template<typename T >

vector2<value_type> std::math::rectangle< T >::center ( )

inline

{ return vector2<T>(x + width / 2, y + height / 2); }

contains()

template<typename T >

bool std::math::rectangle< T >::contains ( rectangle< T >  r )

inline

            {
               return r.left() >= left() && r.right() <= right() &&
                       r.top() >= top() && r.bottom() <= bottom();
            }

inflate()

template<typename T >

rectangle<value_type> std::math::rectangle< T >::inflate ( value_type  leftRight, value_type  topBottom  )

inline

        {
            x -= leftRight;
            width += leftRight * 2;
            y -= topBottom;
        height += topBottom * 2;

        return this;
            }

intersect()

template<typename T >

rectangle<value_type>& std::math::rectangle< T >::intersect ( const rectangle< value_type > &  r1, const rectangle< value_type > &  r2  )

inline

            {
                int x = std::_max<value_type> (r1.x, r2.x);
        int y = std::_max<value_type> (r1.y, r2.y);
        int w = std::_min<value_type> (r1.right(), r2.right()) - x;
        int h = std::_min<value_type> (r1.bottom(), r2.bottom()) - y;
        return rectangle<value_type>(x,y,w,h);
            }

intersects()

template<typename T >

bool std::math::rectangle< T >::intersects ( const rectangle< value_type > &  r )

inline

            {
                int w = std::_min<value_type> (r.right(), right()) - std::_max<value_type> (r.x, x);
        int h = std::_min<value_type> (r.bottom(), bottom()) - std::_max<value_type> (r.y, y);
        return w > 0 && h > 0;
            }

left() [1/2]

template<typename T >

const value_type& std::math::rectangle< T >::left ( )

inline

{ return x; }

left() [2/2]

template<typename T >

void std::math::rectangle< T >::left ( const value_type &  t )

inline

{ x = t; }

offset()

template<typename T >

void std::math::rectangle< T >::offset ( float  offx, float  offy  )

inline

            {
                x += offx;
                y += offy;
            }

right()

template<typename T >

const value_type& std::math::rectangle< T >::right ( )

inline

{ return x + width; }

size()

template<typename T >

vector2<value_type> std::math::rectangle< T >::size ( )

inline

{ return vector2<value_type>(width, height); }

to_string()

template<typename T >

virtual std::string std::math::rectangle< T >::to_string ( )

inlinevirtual

                                          {
                return std::frmstring("[rect] pos: %s size: %s",
                        position.to_string().c_str(), size.to_string().c_str());
            }

top() [1/2]

template<typename T >

const value_type& std::math::rectangle< T >::top ( )

inline

{ return y; }

top() [2/2]

template<typename T >

void std::math::rectangle< T >::top ( const value_type &  t )

inline

{ y = t; }

Dokumentation der Datenelemente

@24

union { ... }

c

template<typename T >

value_type std::math::rectangle< T >::c[4]

height

template<typename T >

value_type std::math::rectangle< T >::height

position

template<typename T >

vector2<T> std::math::rectangle< T >::position

size

template<typename T >

vector2<T> std::math::rectangle< T >::size

width

template<typename T >

value_type std::math::rectangle< T >::width

x

template<typename T >

value_type std::math::rectangle< T >::x

y

template<typename T >

value_type std::math::rectangle< T >::y

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/math/rectangle.hpp