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

#include <matrix4x4.hpp>

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

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

Öffentliche Methoden
	matrix4x4 (const self_type &m)
	matrix4x4 (value_type _m11, value_type _m12, value_type _m13, value_type _m14, value_type _m21, value_type _m22, value_type _m23, value_type _m24, value_type _m31, value_type _m32, value_type _m33, value_type _m34, value_type _m41, value_type _m42, value_type _m43, value_type _m44)
	operator pointer ()
value_type &	operator() (int iRow, int iColumn)
value_type	operator() (int iRow, int iColumn) const
self_type &	operator+= (const self_type &m)
self_type &	operator-= (const self_type &m)
self_type &	operator*= (const self_type &m)
self_type &	operator*= (const value_type f)
self_type &	operator/= (const self_type &m)
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 {
T   m11
T   m12
T   m13
T   m14
T   m21
T   m22
T   m23
T   m24
T   m31
T   m32
T   m33
T   m34
T   m41
T   m42
T   m43
T   m44
}
struct {
vector4< value_type >   row0
vector4< value_type >   row1
vector4< value_type >   row2
vector4< value_type >   row3
}
float   m [4][4]
float   n [16]
};

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T>

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

self_type

template<typename T>

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

value_type

template<typename T>

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

Beschreibung der Konstruktoren und Destruktoren

matrix4x4() [1/2]

template<typename T>

std::math::matrix4x4< T >::matrix4x4 ( const self_type &  m )

inline

                                          : m11(m.m11), m12(m.m12), m13(m.m13), m14(m.m14),
                                      m21(m.m21), m22(m.m22), m23(m.m23), m24(m.m24),
                                      m31(m.m31), m32(m.m32), m33(m.m33), m34(m.m34),
                                      m41(m.m41), m42(m.m42), m43(m.m43), m44(m.m44)                    {}

matrix4x4() [2/2]

template<typename T>

std::math::matrix4x4< T >::matrix4x4 ( value_type  _m11, value_type  _m12, value_type  _m13, value_type  _m14, value_type  _m21, value_type  _m22, value_type  _m23, value_type  _m24, value_type  _m31, value_type  _m32, value_type  _m33, value_type  _m34, value_type  _m41, value_type  _m42, value_type  _m43, value_type  _m44  )

inline

                                                                                          : m11(_m11), m12(_m12), m13(_m13), m14(_m14),
                                                                   m21(_m21), m22(_m22), m23(_m23), m24(_m24),
                                                                   m31(_m31), m32(_m32), m33(_m33), m34(_m34),
                                                                   m41(_m41), m42(_m42), m43(_m43), m44(_m44)   {}

Dokumentation der Elementfunktionen

operator pointer()

template<typename T>

std::math::matrix4x4< T >::operator pointer ( )

inline

{return (pointer)(n);}

operator()() [1/2]

template<typename T>

value_type& std::math::matrix4x4< T >::operator() ( int  iRow, int  iColumn  )

inline

{return m[iRow - 1][iColumn - 1];}

operator()() [2/2]

template<typename T>

value_type std::math::matrix4x4< T >::operator() ( int  iRow, int  iColumn  ) const

inline

{return m[iRow - 1][iColumn - 1];}

operator*=() [1/2]

template<typename T>

self_type& std::math::matrix4x4< T >::operator*= ( const self_type &  m )

inline

        {
         return *this = self_type(m.m11 * m11 + m.m21 * m12 + m.m31 * m13 + m.m41 * m14,
                      m.m12 * m11 + m.m22 * m12 + m.m32 * m13 + m.m42 * m14,
                      m.m13 * m11 + m.m23 * m12 + m.m33 * m13 + m.m43 * m14,
                      m.m14 * m11 + m.m24 * m12 + m.m34 * m13 + m.m44 * m14,
                      m.m11 * m21 + m.m21 * m22 + m.m31 * m23 + m.m41 * m24,
                      m.m12 * m21 + m.m22 * m22 + m.m32 * m23 + m.m42 * m24,
                      m.m13 * m21 + m.m23 * m22 + m.m33 * m23 + m.m43 * m24,
                      m.m14 * m21 + m.m24 * m22 + m.m34 * m23 + m.m44 * m24,
                      m.m11 * m31 + m.m21 * m32 + m.m31 * m33 + m.m41 * m34,
                      m.m12 * m31 + m.m22 * m32 + m.m32 * m33 + m.m42 * m34,
                      m.m13 * m31 + m.m23 * m32 + m.m33 * m33 + m.m43 * m34,
                      m.m14 * m31 + m.m24 * m32 + m.m34 * m33 + m.m44 * m34,
                      m.m11 * m41 + m.m21 * m42 + m.m31 * m43 + m.m41 * m44,
                      m.m12 * m41 + m.m22 * m42 + m.m32 * m43 + m.m42 * m44,
                      m.m13 * m41 + m.m23 * m42 + m.m33 * m43 + m.m43 * m44,
                      m.m14 * m41 + m.m24 * m42 + m.m34 * m43 + m.m44 * m44);
            }

operator*=() [2/2]

template<typename T>

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

inline

            {
            m11 *= f; m12 *= f; m13 *= f; m14 *= f;
            m21 *= f; m22 *= f; m23 *= f; m24 *= f;
            m31 *= f; m32 *= f; m33 *= f; m34 *= f;
            m41 *= f; m42 *= f; m43 *= f; m44 *= f;
            return *this;
            }

operator+=()

template<typename T>

self_type& std::math::matrix4x4< T >::operator+= ( const self_type &  m )

inline

            {
        m11 += m.m11; m12 += m.m12; m13 += m.m13; m14 += m.m14;
        m21 += m.m21; m22 += m.m22; m23 += m.m23; m24 += m.m24;
        m31 += m.m31; m32 += m.m32; m33 += m.m33; m34 += m.m34;
        m41 += m.m41; m42 += m.m42; m43 += m.m43; m44 += m.m44;
        return *this;
            }

operator-=()

template<typename T>

self_type& std::math::matrix4x4< T >::operator-= ( const self_type &  m )

inline

            {
        m11 -= m.m11; m12 -= m.m12; m13 -= m.m13; m14 -= m.m14;
        m21 -= m.m21; m22 -= m.m22; m23 -= m.m23; m24 -= m.m24;
        m31 -= m.m31; m32 -= m.m32; m33 -= m.m33; m34 -= m.m34;
        m41 -= m.m41; m42 -= m.m42; m43 -= m.m43; m44 -= m.m44;
        return *this;
            }

operator/=() [1/2]

template<typename T>

self_type& std::math::matrix4x4< T >::operator/= ( const self_type &  m )

inline

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

operator/=() [2/2]

template<typename T>

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

inline

        {
        m11 /= f; m12 /= f; m13 /= f; m14 /= f;
        m21 /= f; m22 /= f; m23 /= f; m24 /= f;
        m31 /= f; m32 /= f; m33 /= f; m34 /= f;
        m41 /= f; m42 /= f; m43 /= f; m44 /= f;
        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::matrix4x4< T >::to_string ( )

inline

                                                                 {   
                 return std::frmstring<E, TAllocator, TStorage>("{ %s\n  %s\n  %s\n  %s }", 
                std::frmstring<E, TAllocator, TStorage>("{ %.3f %.3f %.3f %.3f }", m11, m12, m13, m14).c_str(),
                std::frmstring<E, TAllocator, TStorage>("{ %.3f %.3f %.3f %.3f }", m21, m22, m23, m24).c_str(),
                std::frmstring<E, TAllocator, TStorage>("{ %.3f %.3f %.3f %.3f }", m31, m32, m33, m34).c_str(),
                std::frmstring<E, TAllocator, TStorage>("{ %.3f %.3f %.3f %.3f }", m41, m42, m43, m44).c_str()
                );
            }

Dokumentation der Datenelemente

@14

union { ... }

m

template<typename T>

float std::math::matrix4x4< T >::m[4][4]

m11

template<typename T>

T std::math::matrix4x4< T >::m11

m12

template<typename T>

T std::math::matrix4x4< T >::m12

m13

template<typename T>

T std::math::matrix4x4< T >::m13

m14

template<typename T>

T std::math::matrix4x4< T >::m14

m21

template<typename T>

T std::math::matrix4x4< T >::m21

m22

template<typename T>

T std::math::matrix4x4< T >::m22

m23

template<typename T>

T std::math::matrix4x4< T >::m23

m24

template<typename T>

T std::math::matrix4x4< T >::m24

m31

template<typename T>

T std::math::matrix4x4< T >::m31

m32

template<typename T>

T std::math::matrix4x4< T >::m32

m33

template<typename T>

T std::math::matrix4x4< T >::m33

m34

template<typename T>

T std::math::matrix4x4< T >::m34

m41

template<typename T>

T std::math::matrix4x4< T >::m41

m42

template<typename T>

T std::math::matrix4x4< T >::m42

m43

template<typename T>

T std::math::matrix4x4< T >::m43

m44

template<typename T>

T std::math::matrix4x4< T >::m44

n

template<typename T>

float std::math::matrix4x4< T >::n[16]

row0

template<typename T>

vector4<value_type> std::math::matrix4x4< T >::row0

row1

template<typename T>

vector4<value_type> std::math::matrix4x4< T >::row1

row2

template<typename T>

vector4<value_type> std::math::matrix4x4< T >::row2

row3

template<typename T>

vector4<value_type> std::math::matrix4x4< T >::row3

---

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

• include/math/matrix4x4.hpp