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

#include <vector4.hpp>

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

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

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

Öffentliche Methoden
	vector4 (void)
	vector4 (const value_type _x, const value_type _y, const value_type _z, const value_type _w)
	vector4 (const value_type f)
	vector4 (const self_type &vec)
	vector4 (const vector3< T > &vec)
	vector4 (const vector2< T > &vec)
	vector4 (const value_type *lpf)
	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 self_type &v)
self_type &	operator/= (const self_type &v)
self_type &	operator/= (const value_type &f)
self_type &	operator*= (const value_type &f)
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage >	to_string ()

Ö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::vector4< T >

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T>

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

self_type

template<typename T>

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

value_type

template<typename T>

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

Beschreibung der Konstruktoren und Destruktoren

vector4() [1/7]

template<typename T>

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

inline

                : x(0), y(0), z(0), w(0)                            {}

vector4() [2/7]

template<typename T>

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

inline

                : x(_x), y(_y), z(_z), w(_w)                    {}

vector4() [3/7]

template<typename T>

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

inline

                : x(f), y(f), z(f), w(f)                            {}

vector4() [4/7]

template<typename T>

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

inline

                : x(vec.x), y(vec.y), z(vec.z), w(vec.w)            {}

vector4() [5/7]

template<typename T>

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

inline

                : x(vec.x), y(vec.y), z(vec.z), w(0)            {}

vector4() [6/7]

template<typename T>

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

inline

                : x(vec.x), y(vec.y), z(0), w(0)            {}

vector4() [7/7]

template<typename T>

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

inline

                : x(lpf[0]), y(lpf[1]), z(lpf[2]), w(lpf[3])        {}

Dokumentation der Elementfunktionen

operator value_type *()

template<typename T>

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

inline

{ return (float*)(c); }

operator void *()

template<typename T>

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

inline

{ return (void*)(c); }

operator*=() [1/2]

template<typename T>

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

inline

{ 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 )

inline

{ 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 )

inline

{ 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 )

inline

{ 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 )

inline

{ 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 )

inline

{ 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 )

inline

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

to_string()

template<typename T>

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string<E, TAllocator, TStorage> std::math::vector4< T >::to_string ( )

inline

                                                                 {   
                return std::frmstring<E, TAllocator, TStorage>("{ %.3f %.3f %.3f %.3f }", 
                        x, y, z, w ); }

Dokumentation der Datenelemente

@38

union { ... }

c

template<typename T>

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

w

template<typename T>

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

x

template<typename T>

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

xyz

template<typename T>

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

y

template<typename T>

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

z

template<typename T>

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

---

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

• include/math/vector4.hpp