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

a clasd for a BoundingBox Mehr ...

#include <boundingbox.hpp>

Öffentliche Typen
using	self_type = boundingbox< T >
using	value_type = T
using	pointer = T *

Öffentliche Methoden
	boundingbox (vector3< T > min, vector3< T > max)
	create the BoundingBox from max and min type Mehr ...
contains_t	contains (const boundingbox< T > &box)
	contain the other box this box Mehr ...
contains_t	contains (vector3< T > point)
	cheak of the point contains this class Mehr ...
void	getcorners (vector3< T > corners[CornerCount])
	get the corners of this box Mehr ...
bool	Intersects (const boundingbox< T > &box)
	cheak of intersect the other box this box Mehr ...
self_type &	operator= (const self_type &v)
vector3< T >	getmin ()
vector3< T >	getmax ()
virtual std::string	to_string ()

Öffentliche Attribute
const int	CornerCount = 8

Ausführliche Beschreibung

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

a clasd for a BoundingBox

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T >

using std::math::boundingbox< T >::pointer = T*

self_type

template<typename T >

using std::math::boundingbox< T >::self_type = boundingbox<T>

value_type

template<typename T >

using std::math::boundingbox< T >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

boundingbox()

template<typename T >

std::math::boundingbox< T >::boundingbox ( vector3< T >  min, vector3< T >  max  )

inline

create the BoundingBox from max and min type

                                                         {
        m_vMin = min;
        m_vMax = max;
            }

Dokumentation der Elementfunktionen

contains() [1/2]

template<typename T >

contains_t std::math::boundingbox< T >::contains ( const boundingbox< T > &  box )

inline

contain the other box this box

Parameter

box	The other box

Rückgabe

Siehe auch

boundingcontains

                                                           {
                if ((m_vMax.x < box.m_vMin.x || m_vMin.x > box.m_vMax.x) ||
           (m_vMax.y < box.m_vMin.y || m_vMin.y > box.m_vMax.y) ||
           (m_vMax.z < box.m_vMin.z || m_vMin.z > box.m_vMax.z)) {
            return contains_t::Disjoint;
        }
                if ((m_vMin.x <= box.m_vMin.x && m_vMax.x >= box.m_vMax.x) &&
           (m_vMin.y <= box.m_vMin.y && m_vMax.y >= box.m_vMax.y) &&
           (m_vMin.z <= box.m_vMin.z && m_vMax.z >= box.m_vMax.z)) {
            return contains_t::Contains;
                }
                return contains_t::Intersects;
            }

contains() [2/2]

template<typename T >

contains_t std::math::boundingbox< T >::contains ( vector3< T >  point )

inline

cheak of the point contains this class

Parameter

point

The to cheaked point

Rückgabe

Siehe auch

boundingcontains

            {
        if ((m_vMin.x <= point.x && m_vMax.x >= point.x) &&
                    (m_vMin.y <= point.y && m_vMax.y >= point.y) &&
                    (m_vMin.z <= point.z && m_vMax.z >= point.z)) {
                    return contains_t::Contains;
        }
        return contains_t::Disjoint;
            }

getcorners()

template<typename T >

void std::math::boundingbox< T >::getcorners ( vector3< T >  corners[CornerCount] )

inline

get the corners of this box

Parameter

corners

the out array

        {
        corners[0] = vector3<T> (m_vMin.x, m_vMax.y, m_vMax.z);
        corners[1] = vector3<T> (m_vMax.x, m_vMax.y, m_vMax.z);
        corners[2] = vector3<T> (m_vMax.x, m_vMin.y, m_vMax.z);
        corners[3] = vector3<T> (m_vMin.x, m_vMin.y, m_vMax.z);
        corners[4] = vector3<T> (m_vMin.x, m_vMax.y, m_vMin.z);
        corners[5] = vector3<T> (m_vMax.x, m_vMax.y, m_vMin.z);
        corners[6] = vector3<T> (m_vMax.x, m_vMin.y, m_vMin.z);
        corners[7] = vector3<T> (m_vMin.x, m_vMin.y, m_vMin.z);
            }

getmax()

template<typename T >

vector3<T> std::math::boundingbox< T >::getmax ( )

inline

{ return m_vMax; }

getmin()

template<typename T >

vector3<T> std::math::boundingbox< T >::getmin ( )

inline

{ return m_vMin; }

Intersects()

template<typename T >

bool std::math::boundingbox< T >::Intersects ( const boundingbox< T > &  box )

inline

cheak of intersect the other box this box

Parameter

box	The other box

Rückgabe

true when this box contains the other box

        {
        return contains (box) == contains_t::Intersects;
        }

operator=()

template<typename T >

self_type& std::math::boundingbox< T >::operator= ( const self_type &  v )

inline

                                                        { 
                m_vMin = m_vMin; m_vMax = v.m_vMax; return *this; } 

to_string()

template<typename T >

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

inlinevirtual

                                          {
                std::frmstring("[bbox] Min: %s  Max: %s", std::to_string(m_vMin), 
                        std::to_string(m_vMax) );
            }

Dokumentation der Datenelemente

CornerCount

template<typename T >

const int std::math::boundingbox< T >::CornerCount = 8

---

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

• include/math/boundingbox.hpp