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

#include <plane.hpp>

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

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

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

Öffentliche Methoden
	plane (void)
	plane (const value_type _x, const value_type _y, const value_type _z, const value_type _w)
	plane (const value_type f)
	plane (const self_type &vec)
	plane (const vector3< T > &vec)
	plane (const vector2< T > &vec)
	plane (const value_type *lpf)
virtual std::string	to_string ()
	operator value_type * ()
	operator void * ()
self_type &	operator+= (const self_type &v)
self_type &	operator-= (const self_type &v)
self_type &	operator*= (const self_type &v)
self_type &	operator*= (const value_type &f)
self_type &	operator/= (const self_type &v)
self_type &	operator/= (const value_type &f)

Öffentliche Attribute
union {
struct {
value_type   x
value_type   y
value_type   z
value_type   w
}
struct {
vector3< value_type >   xyz
}
float   c [4]
};

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T >

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

self_type

template<typename T >

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

value_type

template<typename T >

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

Beschreibung der Konstruktoren und Destruktoren

plane() [1/7]

template<typename T >

std::math::plane< T >::plane ( void  )

inline

                : vector4<T>()                          {}

plane() [2/7]

template<typename T >

std::math::plane< T >::plane ( const value_type  _x, const value_type  _y, const value_type  _z, const value_type  _w  )

inline

                : vector4<T>(_x, _y, _z, _w)                    {}

plane() [3/7]

template<typename T >

std::math::plane< T >::plane ( const value_type  f )

inline

                :  vector4<T>(f, f, f, f)                               {}

plane() [4/7]

template<typename T >

std::math::plane< T >::plane ( const self_type &  vec )

inline

                : vector4<T>(vec.x, vec.y, vec.z, vec.w)            {}

plane() [5/7]

template<typename T >

std::math::plane< T >::plane ( const vector3< T > &  vec )

inline

                : vector4<T>(vec)           {}

plane() [6/7]

template<typename T >

std::math::plane< T >::plane ( const vector2< T > &  vec )

inline

                : vector4<T>(vec)           {}

plane() [7/7]

template<typename T >

std::math::plane< T >::plane ( const value_type *  lpf )

inline

                : vector4<T>(lpf)       {}

Dokumentation der Elementfunktionen

operator value_type *()

template<typename T>

std::math::vector4< T >::operator value_type * ( )

inlineinherited

{ return (float*)(c); }

operator void *()

template<typename T>

std::math::vector4< T >::operator void * ( )

inlineinherited

{ return (void*)(c); }

operator*=() [1/2]

template<typename T>

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

inlineinherited

{ x *= v.x; y *= v.y; z *= v.z; w *= v.w; return *this; }

operator*=() [2/2]

template<typename T>

self_type& std::math::vector4< T >::operator*= ( const value_type &  f )

inlineinherited

{ x *= f; y *= f; z *= f; w *= f; return *this; }

operator+=()

template<typename T>

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

inlineinherited

{ x += v.x; y += v.y; z += v.z; w += v.w; return *this; }

operator-=()

template<typename T>

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

inlineinherited

{ x -= v.x; y -= v.y; z -= v.z; w -= v.w; return *this; }

operator/=() [1/2]

template<typename T>

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

inlineinherited

{ x /= v.x; y /= v.y; z /= v.z; w /= v.w; return *this; }

operator/=() [2/2]

template<typename T>

self_type& std::math::vector4< T >::operator/= ( const value_type &  f )

inlineinherited

{ x /= f; y /= f; z /= f; w /= f; return *this; }

to_string()

template<typename T >

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

inlinevirtual

                                          {
                return std::frmstring("plane: %s", vector4<T>::to_string() );
            }

Dokumentation der Datenelemente

@38

union { ... }

c

template<typename T>

float std::math::vector4< T >::c[4]

inherited

w

template<typename T>

value_type std::math::vector4< T >::w

inherited

x

template<typename T>

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

inherited

xyz

template<typename T>

vector3<value_type> std::math::vector4< T >::xyz

inherited

y

template<typename T>

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

inherited

z

template<typename T>

value_type std::math::vector4< T >::z

inherited

---

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

• include/math/plane.hpp