agg::rgba8T< Colorspace > Struct Template Reference

#include <src/agg/agg_color_rgba.h>

Public Types
enum	base_scale_e { base_shift = 8 , base_scale = 1 << base_shift , base_mask = base_scale - 1 , base_MSB = 1 << (base_shift - 1) }
typedef int8u	value_type
typedef int32u	calc_type
typedef int32	long_type
typedef rgba8T	self_type

Public Member Functions
	rgba8T ()
	rgba8T (unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask)
	rgba8T (const rgba &c)
	rgba8T (const self_type &c, unsigned a_)
template<class T >
	rgba8T (const rgba8T< T > &c)
	operator rgba () const
AGG_INLINE bool	is_transparent () const
AGG_INLINE bool	is_opaque () const
self_type &	clear ()
self_type &	transparent ()
self_type &	opacity (double a_)
double	opacity () const
AGG_INLINE self_type &	premultiply ()
AGG_INLINE self_type &	premultiply (unsigned a_)
AGG_INLINE self_type &	demultiply ()
AGG_INLINE self_type	gradient (const self_type &c, double k) const
AGG_INLINE void	add (const self_type &c, unsigned cover)
template<class GammaLUT >
AGG_INLINE void	apply_gamma_dir (const GammaLUT &gamma)
template<class GammaLUT >
AGG_INLINE void	apply_gamma_inv (const GammaLUT &gamma)

Static Public Member Functions
static void	convert (rgba8T< linear > &dst, const rgba8T< sRGB > &src)
static void	convert (rgba8T< sRGB > &dst, const rgba8T< linear > &src)
static void	convert (rgba8T< linear > &dst, const rgba &src)
static void	convert (rgba8T< sRGB > &dst, const rgba &src)
static void	convert (rgba &dst, const rgba8T< linear > &src)
static void	convert (rgba &dst, const rgba8T< sRGB > &src)
static AGG_INLINE double	to_double (value_type a)
static AGG_INLINE value_type	from_double (double a)
static AGG_INLINE value_type	empty_value ()
static AGG_INLINE value_type	full_value ()
static AGG_INLINE value_type	invert (value_type x)
static AGG_INLINE value_type	multiply (value_type a, value_type b)
static AGG_INLINE value_type	demultiply (value_type a, value_type b)
template<typename T >
static AGG_INLINE T	downscale (T a)
template<typename T >
static AGG_INLINE T	downshift (T a, unsigned n)
static AGG_INLINE value_type	mult_cover (value_type a, cover_type b)
static AGG_INLINE cover_type	scale_cover (cover_type a, value_type b)
static AGG_INLINE value_type	prelerp (value_type p, value_type q, value_type a)
static AGG_INLINE value_type	lerp (value_type p, value_type q, value_type a)
static self_type	no_color ()
static self_type	from_wavelength (double wl, double gamma=1.0)

Public Attributes
value_type	r
value_type	g
value_type	b
value_type	a

Detailed Description

template<class Colorspace>
struct agg::rgba8T< Colorspace >

Member Typedef Documentation

calc_type

template<class Colorspace >

typedef int32u agg::rgba8T< Colorspace >::calc_type

long_type

template<class Colorspace >

typedef int32 agg::rgba8T< Colorspace >::long_type

self_type

template<class Colorspace >

typedef rgba8T agg::rgba8T< Colorspace >::self_type

value_type

template<class Colorspace >

typedef int8u agg::rgba8T< Colorspace >::value_type

Member Enumeration Documentation

base_scale_e

template<class Colorspace >

enum agg::rgba8T::base_scale_e

Enumerator
base_shift
base_scale
base_mask
base_MSB

        {
            base_shift = 8,
            base_scale = 1 << base_shift,
            base_mask  = base_scale - 1,
            base_MSB = 1 << (base_shift - 1)
        };

Constructor & Destructor Documentation

rgba8T() [1/5]

template<class Colorspace >

agg::rgba8T< Colorspace >::rgba8T ( )

inline

{}

rgba8T() [2/5]

template<class Colorspace >

agg::rgba8T< Colorspace >::rgba8T ( unsigned  r_, unsigned  g_, unsigned  b_, unsigned  a_ = base_mask  )

inline

                                                                               :
            r(value_type(r_)), 
            g(value_type(g_)), 
            b(value_type(b_)), 
            a(value_type(a_)) {}

rgba8T() [3/5]

template<class Colorspace >

agg::rgba8T< Colorspace >::rgba8T ( const rgba &  c )

inline

        {
            convert(*this, c);
        }

References agg::rgba8T< Colorspace >::convert().

Here is the call graph for this function:

rgba8T() [4/5]

template<class Colorspace >

agg::rgba8T< Colorspace >::rgba8T ( const self_type &  c, unsigned  a_  )

inline

                                                :
            r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}

rgba8T() [5/5]

template<class Colorspace >

template<class T >

agg::rgba8T< Colorspace >::rgba8T ( const rgba8T< T > &  c )

inline

        {
            convert(*this, c);
        }

References agg::rgba8T< Colorspace >::convert().

Here is the call graph for this function:

Member Function Documentation

add()

template<class Colorspace >

AGG_INLINE void agg::rgba8T< Colorspace >::add ( const self_type &  c, unsigned  cover  )

inline

        {
            calc_type cr, cg, cb, ca;
            if (cover == cover_mask)
            {
                if (c.a == base_mask) 
                {
                    *this = c;
                    return;
                }
                else
                {
                    cr = r + c.r; 
                    cg = g + c.g; 
                    cb = b + c.b; 
                    ca = a + c.a; 
                }
            }
            else
            {
                cr = r + mult_cover(c.r, cover);
                cg = g + mult_cover(c.g, cover);
                cb = b + mult_cover(c.b, cover);
                ca = a + mult_cover(c.a, cover);
            }
            r = (value_type)((cr > calc_type(base_mask)) ? calc_type(base_mask) : cr);
            g = (value_type)((cg > calc_type(base_mask)) ? calc_type(base_mask) : cg);
            b = (value_type)((cb > calc_type(base_mask)) ? calc_type(base_mask) : cb);
            a = (value_type)((ca > calc_type(base_mask)) ? calc_type(base_mask) : ca);
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_mask, agg::cover_mask, agg::rgba8T< Colorspace >::g, agg::rgba8T< Colorspace >::mult_cover(), and agg::rgba8T< Colorspace >::r.

Here is the call graph for this function:

apply_gamma_dir()

template<class Colorspace >

template<class GammaLUT >

AGG_INLINE void agg::rgba8T< Colorspace >::apply_gamma_dir ( const GammaLUT &  gamma )

inline

        {
            r = gamma.dir(r);
            g = gamma.dir(g);
            b = gamma.dir(b);
        }

References agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

apply_gamma_inv()

template<class Colorspace >

template<class GammaLUT >

AGG_INLINE void agg::rgba8T< Colorspace >::apply_gamma_inv ( const GammaLUT &  gamma )

inline

        {
            r = gamma.inv(r);
            g = gamma.inv(g);
            b = gamma.inv(b);
        }

References agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

clear()

template<class Colorspace >

self_type & agg::rgba8T< Colorspace >::clear ( )

inline

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

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

convert() [1/6]

template<class Colorspace >

static void agg::rgba8T< Colorspace >::convert ( rgba &  dst, const rgba8T< linear > &  src  )

inlinestatic

        {
            dst.r = src.r / 255.0;
            dst.g = src.g / 255.0;
            dst.b = src.b / 255.0;
            dst.a = src.a / 255.0;
        }

References agg::rgba::a, agg::rgba8T< Colorspace >::a, agg::rgba::b, agg::rgba8T< Colorspace >::b, agg::rgba::g, agg::rgba8T< Colorspace >::g, agg::rgba::r, and agg::rgba8T< Colorspace >::r.

convert() [2/6]

template<class Colorspace >

static void agg::rgba8T< Colorspace >::convert ( rgba &  dst, const rgba8T< sRGB > &  src  )

inlinestatic

        {
            // Use the "float" table.
            dst.r = sRGB_conv<float>::rgb_from_sRGB(src.r);
            dst.g = sRGB_conv<float>::rgb_from_sRGB(src.g);
            dst.b = sRGB_conv<float>::rgb_from_sRGB(src.b);
            dst.a = sRGB_conv<float>::alpha_from_sRGB(src.a);
        }

References agg::rgba::a, agg::rgba8T< Colorspace >::a, agg::rgba::b, agg::rgba8T< Colorspace >::b, agg::rgba::g, agg::rgba8T< Colorspace >::g, agg::rgba::r, and agg::rgba8T< Colorspace >::r.

convert() [3/6]

template<class Colorspace >

static void agg::rgba8T< Colorspace >::convert ( rgba8T< linear > &  dst, const rgba &  src  )

inlinestatic

        {
            dst.r = value_type(uround(src.r * base_mask));
            dst.g = value_type(uround(src.g * base_mask));
            dst.b = value_type(uround(src.b * base_mask));
            dst.a = value_type(uround(src.a * base_mask));
        }

References agg::rgba::a, agg::rgba8T< Colorspace >::a, agg::rgba::b, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_mask, agg::rgba::g, agg::rgba8T< Colorspace >::g, agg::rgba::r, agg::rgba8T< Colorspace >::r, and agg::uround().

Here is the call graph for this function:

convert() [4/6]

template<class Colorspace >

static void agg::rgba8T< Colorspace >::convert ( rgba8T< linear > &  dst, const rgba8T< sRGB > &  src  )

inlinestatic

        {
            dst.r = sRGB_conv<value_type>::rgb_from_sRGB(src.r);
            dst.g = sRGB_conv<value_type>::rgb_from_sRGB(src.g);
            dst.b = sRGB_conv<value_type>::rgb_from_sRGB(src.b);
            dst.a = src.a;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

Referenced by agg::rgba8T< Colorspace >::rgba8T(), agg::rgba8T< Colorspace >::rgba8T(), and agg::rgba8T< Colorspace >::operator rgba().

Here is the caller graph for this function:

convert() [5/6]

template<class Colorspace >

static void agg::rgba8T< Colorspace >::convert ( rgba8T< sRGB > &  dst, const rgba &  src  )

inlinestatic

        {
            // Use the "float" table.
            dst.r = sRGB_conv<float>::rgb_to_sRGB(float(src.r));
            dst.g = sRGB_conv<float>::rgb_to_sRGB(float(src.g));
            dst.b = sRGB_conv<float>::rgb_to_sRGB(float(src.b));
            dst.a = sRGB_conv<float>::alpha_to_sRGB(float(src.a));
        }

References agg::rgba::a, agg::rgba8T< Colorspace >::a, agg::rgba::b, agg::rgba8T< Colorspace >::b, agg::rgba::g, agg::rgba8T< Colorspace >::g, agg::rgba::r, and agg::rgba8T< Colorspace >::r.

convert() [6/6]

template<class Colorspace >

static void agg::rgba8T< Colorspace >::convert ( rgba8T< sRGB > &  dst, const rgba8T< linear > &  src  )

inlinestatic

        {
            dst.r = sRGB_conv<value_type>::rgb_to_sRGB(src.r);
            dst.g = sRGB_conv<value_type>::rgb_to_sRGB(src.g);
            dst.b = sRGB_conv<value_type>::rgb_to_sRGB(src.b);
            dst.a = src.a;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

demultiply() [1/2]

template<class Colorspace >

AGG_INLINE self_type & agg::rgba8T< Colorspace >::demultiply ( )

inline

        {
            if (a < base_mask)
            {
                if (a == 0)
                {
                    r = g = b = 0;
                }
                else
                {
                    calc_type r_ = (calc_type(r) * base_mask) / a;
                    calc_type g_ = (calc_type(g) * base_mask) / a;
                    calc_type b_ = (calc_type(b) * base_mask) / a;
                    r = value_type((r_ > calc_type(base_mask)) ? calc_type(base_mask) : r_);
                    g = value_type((g_ > calc_type(base_mask)) ? calc_type(base_mask) : g_);
                    b = value_type((b_ > calc_type(base_mask)) ? calc_type(base_mask) : b_);
                }
            }
            return *this;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_mask, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

demultiply() [2/2]

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::demultiply ( value_type  a, value_type  b  )

inlinestatic

        {
            if (a * b == 0)
            {
                return 0;
            }
            else if (a >= b)
            {
                return base_mask;
            }
            else return value_type((a * base_mask + (b >> 1)) / b); 
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, and agg::rgba8T< Colorspace >::base_mask.

downscale()

template<class Colorspace >

template<typename T >

static AGG_INLINE T agg::rgba8T< Colorspace >::downscale ( T  a )

inlinestatic

        {
            return a >> base_shift;
        }

References agg::rgba8T< Colorspace >::a, and agg::rgba8T< Colorspace >::base_shift.

downshift()

template<class Colorspace >

template<typename T >

static AGG_INLINE T agg::rgba8T< Colorspace >::downshift ( T  a, unsigned  n  )

inlinestatic

        {
            return a >> n;
        }

References agg::rgba8T< Colorspace >::a.

empty_value()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::empty_value ( )

inlinestatic

        {
            return 0;
        }

from_double()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::from_double ( double  a )

inlinestatic

        {
            return value_type(uround(a * base_mask));
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::base_mask, and agg::uround().

Here is the call graph for this function:

from_wavelength()

template<class Colorspace >

static self_type agg::rgba8T< Colorspace >::from_wavelength ( double  wl, double  gamma = 1.0  )

inlinestatic

        {
            return self_type(rgba::from_wavelength(wl, gamma));
        }

References agg::rgba::from_wavelength().

Here is the call graph for this function:

full_value()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::full_value ( )

inlinestatic

        {
            return base_mask;
        }

References agg::rgba8T< Colorspace >::base_mask.

gradient()

template<class Colorspace >

AGG_INLINE self_type agg::rgba8T< Colorspace >::gradient ( const self_type &  c, double  k  ) const

inline

        {
            self_type ret;
            calc_type ik = uround(k * base_mask);
            ret.r = lerp(r, c.r, ik);
            ret.g = lerp(g, c.g, ik);
            ret.b = lerp(b, c.b, ik);
            ret.a = lerp(a, c.a, ik);
            return ret;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_mask, agg::rgba8T< Colorspace >::g, agg::rgba8T< Colorspace >::lerp(), agg::rgba8T< Colorspace >::r, and agg::uround().

Here is the call graph for this function:

invert()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::invert ( value_type  x )

inlinestatic

        {
            return base_mask - x;
        }

References agg::rgba8T< Colorspace >::base_mask.

is_opaque()

template<class Colorspace >

AGG_INLINE bool agg::rgba8T< Colorspace >::is_opaque ( ) const

inline

        {
            return a == base_mask;
        }

References agg::rgba8T< Colorspace >::a, and agg::rgba8T< Colorspace >::base_mask.

is_transparent()

template<class Colorspace >

AGG_INLINE bool agg::rgba8T< Colorspace >::is_transparent ( ) const

inline

        {
            return a == 0;
        }

References agg::rgba8T< Colorspace >::a.

lerp()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::lerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

        {
            int t = (q - p) * a + base_MSB - (p > q);
            return value_type(p + (((t >> base_shift) + t) >> base_shift));
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::base_MSB, and agg::rgba8T< Colorspace >::base_shift.

Referenced by agg::rgba8T< Colorspace >::gradient().

Here is the caller graph for this function:

mult_cover()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::mult_cover ( value_type  a, cover_type  b  )

inlinestatic

        {
            return multiply(a, b);
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, and agg::rgba8T< Colorspace >::multiply().

Referenced by agg::rgba8T< Colorspace >::add().

Here is the call graph for this function:

Here is the caller graph for this function:

multiply()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::multiply ( value_type  a, value_type  b  )

inlinestatic

        {
            calc_type t = a * b + base_MSB;
            return value_type(((t >> base_shift) + t) >> base_shift);
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_MSB, and agg::rgba8T< Colorspace >::base_shift.

Referenced by agg::rgba8T< Colorspace >::mult_cover(), agg::rgba8T< Colorspace >::prelerp(), agg::rgba8T< Colorspace >::premultiply(), and agg::rgba8T< Colorspace >::scale_cover().

Here is the caller graph for this function:

no_color()

template<class Colorspace >

static self_type agg::rgba8T< Colorspace >::no_color ( )

inlinestatic

{ return self_type(0,0,0,0); }

opacity() [1/2]

template<class Colorspace >

double agg::rgba8T< Colorspace >::opacity ( ) const

inline

        {
            return double(a) / double(base_mask);
        }

References agg::rgba8T< Colorspace >::a, and agg::rgba8T< Colorspace >::base_mask.

opacity() [2/2]

template<class Colorspace >

self_type & agg::rgba8T< Colorspace >::opacity ( double  a_ )

inline

        {
            if (a_ < 0) a = 0;
            else if (a_ > 1) a = 1;
            else a = (value_type)uround(a_ * double(base_mask));
            return *this;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::base_mask, and agg::uround().

Here is the call graph for this function:

operator rgba()

template<class Colorspace >

agg::rgba8T< Colorspace >::operator rgba ( ) const

inline

        {
            rgba c;
            convert(c, *this);
            return c;
        }

References agg::rgba8T< Colorspace >::convert().

Here is the call graph for this function:

prelerp()

template<class Colorspace >

static AGG_INLINE value_type agg::rgba8T< Colorspace >::prelerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

        {
            return p + q - multiply(p, a);
        }

References agg::rgba8T< Colorspace >::a, and agg::rgba8T< Colorspace >::multiply().

Here is the call graph for this function:

premultiply() [1/2]

template<class Colorspace >

AGG_INLINE self_type & agg::rgba8T< Colorspace >::premultiply ( )

inline

        {
            if (a != base_mask)
            {
                if (a == 0)
                {
                    r = g = b = 0;
                }
                else
                {
                    r = multiply(r, a);
                    g = multiply(g, a);
                    b = multiply(b, a);
                }
            }
            return *this;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_mask, agg::rgba8T< Colorspace >::g, agg::rgba8T< Colorspace >::multiply(), and agg::rgba8T< Colorspace >::r.

Here is the call graph for this function:

premultiply() [2/2]

template<class Colorspace >

AGG_INLINE self_type & agg::rgba8T< Colorspace >::premultiply ( unsigned  a_ )

inline

        {
            if (a != base_mask || a_ < base_mask)
            {
                if (a == 0 || a_ == 0)
                {
                    r = g = b = a = 0;
                }
                else
                {
                    calc_type r_ = (calc_type(r) * a_) / a;
                    calc_type g_ = (calc_type(g) * a_) / a;
                    calc_type b_ = (calc_type(b) * a_) / a;
                    r = value_type((r_ > a_) ? a_ : r_);
                    g = value_type((g_ > a_) ? a_ : g_);
                    b = value_type((b_ > a_) ? a_ : b_);
                    a = value_type(a_);
                }
            }
            return *this;
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, agg::rgba8T< Colorspace >::base_mask, agg::rgba8T< Colorspace >::g, and agg::rgba8T< Colorspace >::r.

scale_cover()

template<class Colorspace >

static AGG_INLINE cover_type agg::rgba8T< Colorspace >::scale_cover ( cover_type  a, value_type  b  )

inlinestatic

        {
            return multiply(b, a);
        }

References agg::rgba8T< Colorspace >::a, agg::rgba8T< Colorspace >::b, and agg::rgba8T< Colorspace >::multiply().

Here is the call graph for this function:

to_double()

template<class Colorspace >

static AGG_INLINE double agg::rgba8T< Colorspace >::to_double ( value_type  a )

inlinestatic

        {
            return double(a) / base_mask;
        }

References agg::rgba8T< Colorspace >::a, and agg::rgba8T< Colorspace >::base_mask.

transparent()

template<class Colorspace >

self_type & agg::rgba8T< Colorspace >::transparent ( )

inline

        {
            a = 0;
            return *this;
        }

References agg::rgba8T< Colorspace >::a.

Member Data Documentation

a

template<class Colorspace >

value_type agg::rgba8T< Colorspace >::a

Referenced by agg::rgba8T< Colorspace >::add(), agg::rgba8T< Colorspace >::clear(), agg::gray8T< Colorspace >::convert(), agg::gray8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::demultiply(), agg::rgba8T< Colorspace >::demultiply(), agg::rgba8T< Colorspace >::downscale(), agg::rgba8T< Colorspace >::downshift(), agg::rgba8T< Colorspace >::from_double(), agg::rgba8T< Colorspace >::gradient(), agg::rgba8T< Colorspace >::is_opaque(), agg::rgba8T< Colorspace >::is_transparent(), agg::rgba8T< Colorspace >::lerp(), agg::rgba8T< Colorspace >::mult_cover(), agg::rgba8T< Colorspace >::multiply(), agg::rgba8T< Colorspace >::opacity(), agg::rgba8T< Colorspace >::opacity(), agg::rgba8T< Colorspace >::prelerp(), agg::rgba8T< Colorspace >::premultiply(), agg::rgba8T< Colorspace >::premultiply(), agg::rgba8T< Colorspace >::scale_cover(), agg::rgba8T< Colorspace >::to_double(), and agg::rgba8T< Colorspace >::transparent().

b

template<class Colorspace >

value_type agg::rgba8T< Colorspace >::b

Referenced by agg::rgba8T< Colorspace >::add(), agg::rgba8T< Colorspace >::apply_gamma_dir(), agg::rgba8T< Colorspace >::apply_gamma_inv(), agg::rgba8T< Colorspace >::clear(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::demultiply(), agg::rgba8T< Colorspace >::demultiply(), agg::rgba8T< Colorspace >::gradient(), agg::rgba8T< Colorspace >::mult_cover(), agg::rgba8T< Colorspace >::multiply(), agg::rgba8T< Colorspace >::premultiply(), agg::rgba8T< Colorspace >::premultiply(), and agg::rgba8T< Colorspace >::scale_cover().

g

template<class Colorspace >

value_type agg::rgba8T< Colorspace >::g

Referenced by agg::rgba8T< Colorspace >::add(), agg::rgba8T< Colorspace >::apply_gamma_dir(), agg::rgba8T< Colorspace >::apply_gamma_inv(), agg::rgba8T< Colorspace >::clear(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::demultiply(), agg::rgba8T< Colorspace >::gradient(), agg::rgba8T< Colorspace >::premultiply(), and agg::rgba8T< Colorspace >::premultiply().

r

template<class Colorspace >

value_type agg::rgba8T< Colorspace >::r

Referenced by agg::rgba8T< Colorspace >::add(), agg::rgba8T< Colorspace >::apply_gamma_dir(), agg::rgba8T< Colorspace >::apply_gamma_inv(), agg::rgba8T< Colorspace >::clear(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::convert(), agg::rgba8T< Colorspace >::demultiply(), agg::rgba8T< Colorspace >::gradient(), agg::rgba8T< Colorspace >::premultiply(), and agg::rgba8T< Colorspace >::premultiply().

---

The documentation for this struct was generated from the following file:

• src/agg/agg_color_rgba.h