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

#include <quaternion.hpp>

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

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

Öffentliche Typen
typedef T	value_type
typedef quaternion< T >	self_type

Öffentliche Methoden
virtual std::string	to_string ()
	quaternion ()
	quaternion (float _s, vector3< value_type > axis)
	quaternion (const vector3< value_type > &axis)
	quaternion (float fs, float x, float y, float z)
	quaternion (float *pfs)
	operator T* ()
	operator const T * () const
self_type &	operator= (const self_type &q)
self_type &	operator+= (const self_type &q)
self_type &	operator-= (const self_type &q)
self_type &	operator*= (const self_type &b)
self_type &	operator*= (const value_type f)
self_type &	operator/= (const self_type &q)
self_type &	operator/= (const value_type f)

Öffentliche Attribute
union {
struct {
vector3< value_type >   v
float   s
}
vector4< value_type >   vec
float   qu [4]
};

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

self_type

template<typename T >

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

value_type

template<typename T >

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

Beschreibung der Konstruktoren und Destruktoren

quaternion() [1/5]

template<typename T >

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

inline

: s(1.0f), v(vector3<value_type>(0.0f)) {}

quaternion() [2/5]

template<typename T >

std::math::quaternion< T >::quaternion ( float  _s, vector3< value_type >  axis  )

inline

: s(_s), v(axis) {} 

quaternion() [3/5]

template<typename T >

std::math::quaternion< T >::quaternion

(

const vector3< value_type > &

axis

)

                                                              {
            value_type cos_z_2 = (value_type)cos(0.5*axis.z);
            value_type cos_y_2 = (value_type)cos(0.5*axis.y);
            value_type cos_x_2 = (value_type)cos(0.5*axis.x);

            value_type sin_z_2 = (value_type)sin(0.5*axis.z);
            value_type sin_y_2 = (value_type)sin(0.5*axis.y);
            value_type sin_x_2 = (value_type)sin(0.5*axis.x);

            // and now compute quaternion
            s   = cos_z_2*cos_y_2*cos_x_2 + sin_z_2*sin_y_2*sin_x_2;
            v.x = cos_z_2*cos_y_2*sin_x_2 - sin_z_2*sin_y_2*cos_x_2;
            v.y = cos_z_2*sin_y_2*cos_x_2 + sin_z_2*cos_y_2*sin_x_2;
            v.z = sin_z_2*cos_y_2*cos_x_2 - cos_z_2*sin_y_2*sin_x_2;
        }

quaternion() [4/5]

template<typename T >

std::math::quaternion< T >::quaternion ( float  fs, float  x, float  y, float  z  )

inline

: s(fs), v(vector3<value_type>(x,y,z))  {}

quaternion() [5/5]

template<typename T >

std::math::quaternion< T >::quaternion ( float *  pfs )

inline

: s(pfs[0]), v(vector3<value_type>(pfs[1],pfs[2],pfs[3]))   {}

Dokumentation der Elementfunktionen

operator const T *()

template<typename T >

std::math::quaternion< T >::operator const T * ( ) const

inline

{ return (float*)qu; }

operator T*()

template<typename T >

std::math::quaternion< T >::operator T* ( )

inline

{ return (T*)(qu); }

operator*=() [1/2]

template<typename T >

self_type& std::math::quaternion< T >::operator*= ( const self_type &  b )

inline

                                                    {
                s =   ((s * b.s) - (v.x * b.v.x) - (v.y * b.v.z) - (v.z * b.v.z));
                v.x = ((s * b.v.x) + (v.x * b.s) + (v.y * b.v.y) - (v.z * b.v.y));
            v.y = ((s * b.v.y) - (v.x * b.v.z) + (v.y * b.s) + (v.z * b.v.x));
            v.z = ((s * b.v.z) + (v.x * b.v.y) - (v.y * b.v.x) + (v.z * b.s));
                return *this;
            }

operator*=() [2/2]

template<typename T >

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

inline

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

operator+=()

template<typename T >

self_type& std::math::quaternion< T >::operator+= ( const self_type &  q )

inline

                { v += q.v; s += q.s; return *this; }

operator-=()

template<typename T >

self_type& std::math::quaternion< T >::operator-= ( const self_type &  q )

inline

                { v -= q.v; s -= q.s; return *this; }

operator/=() [1/2]

template<typename T >

quaternion< T > & std::math::quaternion< T >::operator/=

(

const self_type &

q

)

                                                                      {
            (* this) *= invert(q); return *this;
        }

operator/=() [2/2]

template<typename T >

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

inline

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

operator=()

template<typename T >

self_type& std::math::quaternion< T >::operator= ( const self_type &  q )

inline

                { v = q.v; s = q.s; return *this; }

to_string()

template<typename T >

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

inlinevirtual

                                          {
                return std::frmstring("quad: %s", vec.to_string().c_str());
            }

Dokumentation der Datenelemente

@20

union { ... }

qu

template<typename T >

float std::math::quaternion< T >::qu[4]

s

template<typename T >

float std::math::quaternion< T >::s

v

template<typename T >

vector3<value_type> std::math::quaternion< T >::v

vec

template<typename T >

vector4<value_type> std::math::quaternion< T >::vec

---

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

• include/math/quaternion.hpp