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

#include <physik.hpp>

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

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

Öffentliche Typen
typedef physik_base< T >	physik_value
typedef T	value_type
typedef T *	pointer
typedef physik< T >	self_type

Öffentliche Methoden
	physik (physik_value *o)
	physik (physik_value *o, const vector3< T > &Position, const vector3< T > &Velocity, const vector3< T > &Accelerator, T mass=1.0)
virtual void	update (value_type fTime, value_type fRunTime)
void	reset ()
void	accelerate (const vector3< T > &accel)
void	angaccel (vector3< T > accel)
void	set_accelerate (vector3< T > Acc)
void	set_angaccel (vector3< T > Ang)
vector3< T >	position ()
vector3< T >	velocity ()
value_type	mass ()
value_type	getBoundingsphereRadius ()
void	set_velocity (vector3< T > velo)
virtual std::string	to_string ()

Ausführliche Beschreibung

template<typename T = double>
class std::math::physik< T >

Dokumentation der benutzerdefinierten Datentypen

physik_value

template<typename T = double>

typedef physik_base<T> std::math::physik< T >::physik_value

pointer

template<typename T = double>

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

self_type

template<typename T = double>

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

value_type

template<typename T = double>

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

Beschreibung der Konstruktoren und Destruktoren

physik() [1/2]

template<typename T = double>

std::math::physik< T >::physik ( physik_value *  o )

inline

                                    :
        m_Velocity(0,0,0), m_Accelerate(0,0,0), m_AngularAccelerate(0,0,0), m_AngularVelocity(0,0,0)
            {
                    m_pRender = o;
                    m_Translation = matrix4x4_identity();
                    m_Rotation = matrix4x4_identity();
                    m_Scaling = scaling(vector3<T>(m_pRender->getWorldMatrix()->m11,  m_pRender->getWorldMatrix()->m22,
                                                          m_pRender->getWorldMatrix()->m33));
                    m_Mass = 1;
            }

physik() [2/2]

template<typename T = double>

std::math::physik< T >::physik ( physik_value *  o, const vector3< T > &  Position, const vector3< T > &  Velocity, const vector3< T > &  Accelerator, T  mass = 1.0  )

inline

                                 :
                    m_Velocity(Velocity), m_Accelerate(Accelerator), m_AngularVelocity(0,0,0), m_AngularAccelerate(0,0,0)
            {
                    m_pRender = o;
                    m_Translation = translate(matrix4x4_identity(), Position);
                    m_Rotation = matrix4x4_identity();
                    m_Scaling = scaling(vector3<T>(m_pRender->getWorldMatrix()->m11,
                                                          m_pRender->getWorldMatrix()->m22,
                                                         m_pRender->getWorldMatrix()->m33));
                    m_Mass = mass;
            }

Dokumentation der Elementfunktionen

accelerate()

template<typename T = double>

void std::math::physik< T >::accelerate ( const vector3< T > &  accel )

inline

            {
        m_Accelerate = transformnormal(accel, m_pRender->getWorldMatrix());
            }

angaccel()

template<typename T = double>

void std::math::physik< T >::angaccel ( vector3< T >  accel )

inline

            {
        m_AngularAccelerate = transformnormal(accel, m_pRender->getWorldMatrix());
            }

getBoundingsphereRadius()

template<typename T = double>

value_type std::math::physik< T >::getBoundingsphereRadius ( )

inline

                { return m_pRender->getBoundingsphereRadius(); }

mass()

template<typename T = double>

value_type std::math::physik< T >::mass ( )

inline

                { return m_Mass; }

position()

template<typename T = double>

vector3<T> std::math::physik< T >::position ( )

inline

                { return transformcoord(vector3<T>(0), m_Translation); }

reset()

template<typename T = double>

void std::math::physik< T >::reset

(

)

        {
            m_Accelerate = vector3<T>(0);
            m_AngularAccelerate = vector3<T>(0);
            m_AngularVelocity = vector3<T>(0);
            m_Velocity = vector3<T>(0);
        }

set_accelerate()

template<typename T = double>

void std::math::physik< T >::set_accelerate ( vector3< T >  Acc )

inline

                {  m_Accelerate= Acc; }

set_angaccel()

template<typename T = double>

void std::math::physik< T >::set_angaccel ( vector3< T >  Ang )

inline

                { m_AngularAccelerate = Ang; }

set_velocity()

template<typename T = double>

void std::math::physik< T >::set_velocity ( vector3< T >  velo )

inline

                { m_Velocity = velo; }

to_string()

template<typename T = double>

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

inlinevirtual

                                          {
                std::frmstring("[physik] pos: %s vel: %s\nmass: %.3f bsradius: %.3f", 
                       position().to_string() , velocity().to_string(),
                       mass,  getBoundingsphereRadius);
            }

update()

template<typename T = double>

void std::math::physik< T >::update ( value_type  fTime, value_type  fRunTime  )

virtual

        {
            float angle = fTime * lenghtSq(m_AngularAccelerate);
        vector3<T> axis = normalize(m_AngularVelocity);
            
            if(m_pRender)
            {
        matrix4x4<T> mWorld = matrix4x4_identity(), m = matrix4x4_identity();
                m_Rotation = rotate(m_Rotation, axis, angle);
        m_Translation = translate(m_Translation, scale(m_Velocity, fTime));
                
        m = m_Scaling * m_Rotation;
        mWorld = m * m_Translation;

        m_pRender->setWorldMatrix(mWorld);
        }
        m_Velocity += fTime * m_Accelerate;
        m_AngularVelocity += fTime * m_AngularAccelerate;       
        }

velocity()

template<typename T = double>

vector3<T> std::math::physik< T >::velocity ( )

inline

                { return m_Velocity; }

---

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

• include/math/physik.hpp