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

#include <color.hpp>

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

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

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

Öffentliche Methoden
	color (void)
	color (value_type _r, value_type _g, value_type _b, value_type _a)
	color (value_type _r, value_type _g, value_type _b)
	color (value_type f)
	color (value_type *com)
	color (const int _r, const int _g, const int _b)
	color (const int _r, const int _g, const int _b, const int _a)
	color (const int *pComponent)
	color (const int c)
	operator unsigned long () const
	operator T* ()
self_type &	operator= (const self_type &c)
self_type &	operator+= (const self_type &c)
self_type &	operator-= (const self_type &c)
self_type &	operator*= (const self_type &c)
self_type &	operator*= (const value_type f)
self_type &	operator/= (const self_type &c)
self_type &	operator/= (const value_type f)
virtual std::string	to_string ()

Öffentliche Attribute
union {
struct {
value_type   r
value_type   g
value_type   b
value_type   a
}
struct {
value_type   red
value_type   green
value_type   blue
value_type   alpha
}
value_type   c [4]
};

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

pointer

template<typename T >

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

self_type

template<typename T >

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

value_type

template<typename T >

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

Beschreibung der Konstruktoren und Destruktoren

color() [1/9]

template<typename T >

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

inline

{}

color() [2/9]

template<typename T >

std::math::color< T >::color ( value_type  _r, value_type  _g, value_type  _b, value_type  _a  )

inline

: r(_r), g(_g), b(_b), a(_a)                                                                                                                            {}

color() [3/9]

template<typename T >

std::math::color< T >::color ( value_type  _r, value_type  _g, value_type  _b  )

inline

: r(_r), g(_g), b(_b), a(1.0)                                                                                                                                   {}

color() [4/9]

template<typename T >

std::math::color< T >::color ( value_type  f )

inline

: r(f), g(f), b(f), a(f)                                                                                                                                                                {}

color() [5/9]

template<typename T >

std::math::color< T >::color ( value_type *  com )

inline

: r(com[0]), g(com[1]), b(com[2]), a(com[3])                                                                                                                                    {}

color() [6/9]

template<typename T >

std::math::color< T >::color ( const int  _r, const int  _g, const int  _b  )

inline

: r((T)(_r) * colorcon), g((T)(_g) * colorcon), b((T)(_b) * colorcon), a(1.0f)                                                      {}

color() [7/9]

template<typename T >

std::math::color< T >::color ( const int  _r, const int  _g, const int  _b, const int  _a  )

inline

: r((T)(_r) * colorcon), g((T)(_g) * colorcon), b((T)(_b) * colorcon), a((T)(_a) * colorcon)                    {}

color() [8/9]

template<typename T >

std::math::color< T >::color ( const int *  pComponent )

inline

: r((T)(pComponent[0]) * colorcon), g((T)(pComponent[1]) * colorcon), b((T)(pComponent[2]) * colorcon), a((T)(pComponent[3]) * colorcon)        {}

color() [9/9]

template<typename T >

std::math::color< T >::color ( const int  c )

inline

: r(colorcon * (T)(c >> 16)), g(colorcon * (T)(c >> 8)), b(colorcon * (T)(c)), a(colorcon * (T)(c >> 24))                           {}

Dokumentation der Elementfunktionen

operator T*()

template<typename T >

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

inline

{return (T*)(c);}

operator unsigned long()

template<typename T >

std::math::color< T >::operator unsigned long ( ) const

inline

        {
        return ((a >= 1.0f ? 255 : a <= 0.0f ? 0 : (unsigned long)(a * 255.0f)) << 24) |
                    ((r >= 1.0f ? 255 : r <= 0.0f ? 0 : (unsigned long)(r * 255.0f)) << 16) |
                    ((g >= 1.0f ? 255 : g <= 0.0f ? 0 : (unsigned long)(g * 255.0f)) << 8)  |
                    (b >= 1.0f ? 255 : b <= 0.0f ? 0 : (unsigned long)(b * 255.0f));
            }

operator*=() [1/2]

template<typename T >

self_type& std::math::color< T >::operator*= ( const self_type &  c )

inline

{r *= c.r; g *= c.g; b *= c.b; a *= c.a; return *this;}

operator*=() [2/2]

template<typename T >

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

inline

{r *= f; g *= f; b *= f; a *= f; return *this;}

operator+=()

template<typename T >

self_type& std::math::color< T >::operator+= ( const self_type &  c )

inline

{r += c.r; g += c.g; b += c.b; a += c.a; return *this;}

operator-=()

template<typename T >

self_type& std::math::color< T >::operator-= ( const self_type &  c )

inline

{r -= c.r; g -= c.g; b -= c.b; a -= c.a; return *this;}

operator/=() [1/2]

template<typename T >

self_type& std::math::color< T >::operator/= ( const self_type &  c )

inline

{r /= c.r; g /= c.g; b /= c.b; a /= c.a; return *this;}

operator/=() [2/2]

template<typename T >

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

inline

{r /= f; g /= f; b /= f; a /= f; return *this;}

operator=()

template<typename T >

self_type& std::math::color< T >::operator= ( const self_type &  c )

inline

{a = c.a; b = c.b; g = c.g; r = c.r; return *this;}

to_string()

template<typename T >

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

inlinevirtual

                                          {
                return std::frmstring("Color: R:%d G:%d B:%d A:%d",
                        red, green, blue, alpha);
            }

Dokumentation der Datenelemente

@8

union { ... }

a

template<typename T >

value_type std::math::color< T >::a

alpha

template<typename T >

value_type std::math::color< T >::alpha

b

template<typename T >

value_type std::math::color< T >::b

blue

template<typename T >

value_type std::math::color< T >::blue

c

template<typename T >

value_type std::math::color< T >::c[4]

g

template<typename T >

value_type std::math::color< T >::g

green

template<typename T >

value_type std::math::color< T >::green

r

template<typename T >

value_type std::math::color< T >::r

red

template<typename T >

value_type std::math::color< T >::red

---

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

• include/math/color.hpp