agg::rgba16 Struct Reference

#include <src/agg/agg_color_rgba.h>

Public Types
enum	base_scale_e { base_shift = 16 , base_scale = 1 << base_shift , base_mask = base_scale - 1 , base_MSB = 1 << (base_shift - 1) }
typedef int16u	value_type
typedef int32u	calc_type
typedef int64	long_type
typedef rgba16	self_type

Public Member Functions
	rgba16 ()
	rgba16 (unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask)
	rgba16 (const self_type &c, unsigned a_)
	rgba16 (const rgba &c)
	rgba16 (const rgba8 &c)
	rgba16 (const srgba8 &c)
	operator rgba () const
	operator rgba8 () const
	operator srgba8 () const
AGG_INLINE bool	is_transparent () const
AGG_INLINE bool	is_opaque () const
self_type &	clear ()
self_type &	transparent ()
AGG_INLINE 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 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

Member Typedef Documentation

calc_type

typedef int32u agg::rgba16::calc_type

long_type

typedef int64 agg::rgba16::long_type

self_type

typedef rgba16 agg::rgba16::self_type

value_type

typedef int16u agg::rgba16::value_type

Member Enumeration Documentation

base_scale_e

enum agg::rgba16::base_scale_e

Enumerator
base_shift
base_scale
base_mask
base_MSB

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

Constructor & Destructor Documentation

rgba16() [1/6]

agg::rgba16::rgba16 ( )

inline

{}

rgba16() [2/6]

agg::rgba16::rgba16 ( 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_)) {}

rgba16() [3/6]

agg::rgba16::rgba16 ( const self_type &  c, unsigned  a_  )

inline

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

rgba16() [4/6]

agg::rgba16::rgba16 ( const rgba &  c )

inline

                              :
            r((value_type)uround(c.r * double(base_mask))), 
            g((value_type)uround(c.g * double(base_mask))), 
            b((value_type)uround(c.b * double(base_mask))), 
            a((value_type)uround(c.a * double(base_mask))) {}

rgba16() [5/6]

agg::rgba16::rgba16 ( const rgba8 &  c )

inline

                               :
            r(value_type((value_type(c.r) << 8) | c.r)), 
            g(value_type((value_type(c.g) << 8) | c.g)), 
            b(value_type((value_type(c.b) << 8) | c.b)), 
            a(value_type((value_type(c.a) << 8) | c.a)) {}

rgba16() [6/6]

agg::rgba16::rgba16 ( const srgba8 &  c )

inline

                                :
            r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)), 
            g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)), 
            b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)), 
            a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}

Member Function Documentation

add()

AGG_INLINE void agg::rgba16::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 a, b, base_mask, agg::cover_mask, g, mult_cover(), and r.

Here is the call graph for this function:

apply_gamma_dir()

template<class GammaLUT >

AGG_INLINE void agg::rgba16::apply_gamma_dir ( const GammaLUT &  gamma )

inline

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

References b, g, and r.

apply_gamma_inv()

template<class GammaLUT >

AGG_INLINE void agg::rgba16::apply_gamma_inv ( const GammaLUT &  gamma )

inline

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

References b, g, and r.

clear()

self_type & agg::rgba16::clear ( )

inline

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

References a, b, g, and r.

demultiply() [1/2]

AGG_INLINE self_type & agg::rgba16::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 a, b, base_mask, g, and r.

demultiply() [2/2]

static AGG_INLINE value_type agg::rgba16::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 a, b, and base_mask.

downscale()

template<typename T >

static AGG_INLINE T agg::rgba16::downscale ( T  a )

inlinestatic

        {
            return a >> base_shift;
        }

References a, and base_shift.

downshift()

template<typename T >

static AGG_INLINE T agg::rgba16::downshift ( T  a, unsigned  n  )

inlinestatic

        {
            return a >> n;
        }

References a.

empty_value()

static AGG_INLINE value_type agg::rgba16::empty_value ( )

inlinestatic

        {
            return 0;
        }

from_double()

static AGG_INLINE value_type agg::rgba16::from_double ( double  a )

inlinestatic

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

References a, base_mask, and agg::uround().

Here is the call graph for this function:

from_wavelength()

static self_type agg::rgba16::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()

static AGG_INLINE value_type agg::rgba16::full_value ( )

inlinestatic

        {
            return base_mask;
        }

References base_mask.

gradient()

AGG_INLINE self_type agg::rgba16::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 a, b, base_mask, g, lerp(), r, and agg::uround().

Here is the call graph for this function:

invert()

static AGG_INLINE value_type agg::rgba16::invert ( value_type  x )

inlinestatic

        {
            return base_mask - x;
        }

References base_mask.

is_opaque()

AGG_INLINE bool agg::rgba16::is_opaque ( ) const

inline

        {
            return a == base_mask;
        }

References a, and base_mask.

is_transparent()

AGG_INLINE bool agg::rgba16::is_transparent ( ) const

inline

        {
            return a == 0;
        }

References a.

lerp()

static AGG_INLINE value_type agg::rgba16::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 a, base_MSB, and base_shift.

Referenced by gradient().

Here is the caller graph for this function:

mult_cover()

static AGG_INLINE value_type agg::rgba16::mult_cover ( value_type  a, cover_type  b  )

inlinestatic

        {
            return multiply(a, (b << 8) | b);
        }

References a, b, and multiply().

Referenced by add().

Here is the call graph for this function:

Here is the caller graph for this function:

multiply()

static AGG_INLINE value_type agg::rgba16::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 a, b, base_MSB, and base_shift.

Referenced by mult_cover(), prelerp(), premultiply(), and scale_cover().

Here is the caller graph for this function:

no_color()

static self_type agg::rgba16::no_color ( )

inlinestatic

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

opacity() [1/2]

double agg::rgba16::opacity ( ) const

inline

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

References a, and base_mask.

opacity() [2/2]

AGG_INLINE self_type & agg::rgba16::opacity ( double  a_ )

inline

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

References a, base_mask, and agg::uround().

Here is the call graph for this function:

operator rgba()

agg::rgba16::operator rgba ( ) const

inline

        {
            return rgba(
                r / 65535.0, 
                g / 65535.0, 
                b / 65535.0, 
                a / 65535.0);
        }

References a, b, g, and r.

operator rgba8()

agg::rgba16::operator rgba8 ( ) const

inline

        {
            return rgba8(r >> 8, g >> 8, b >> 8, a >> 8);
        }

References a, b, g, and r.

operator srgba8()

agg::rgba16::operator srgba8 ( ) const

inline

        {
            // Return (non-premultiplied) sRGB values.
            return srgba8(
                sRGB_conv<value_type>::rgb_to_sRGB(r), 
                sRGB_conv<value_type>::rgb_to_sRGB(g), 
                sRGB_conv<value_type>::rgb_to_sRGB(b), 
                sRGB_conv<value_type>::alpha_to_sRGB(a));
        }

References a, b, g, and r.

prelerp()

static AGG_INLINE value_type agg::rgba16::prelerp ( value_type  p, value_type  q, value_type  a  )

inlinestatic

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

References a, and multiply().

Here is the call graph for this function:

premultiply() [1/2]

AGG_INLINE self_type & agg::rgba16::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 a, b, base_mask, g, multiply(), and r.

Here is the call graph for this function:

premultiply() [2/2]

AGG_INLINE self_type & agg::rgba16::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 a, b, base_mask, g, and r.

scale_cover()

static AGG_INLINE cover_type agg::rgba16::scale_cover ( cover_type  a, value_type  b  )

inlinestatic

        {
            return multiply((a << 8) | a, b) >> 8;
        }

References a, b, and multiply().

Here is the call graph for this function:

to_double()

static AGG_INLINE double agg::rgba16::to_double ( value_type  a )

inlinestatic

        {
            return double(a) / base_mask;
        }

References a, and base_mask.

transparent()

self_type & agg::rgba16::transparent ( )

inline

        {
            a = 0;
            return *this;
        }

References a.

Member Data Documentation

a

value_type agg::rgba16::a

Referenced by add(), clear(), demultiply(), demultiply(), downscale(), downshift(), from_double(), gradient(), is_opaque(), is_transparent(), lerp(), mult_cover(), multiply(), opacity(), opacity(), operator rgba(), operator rgba8(), operator srgba8(), prelerp(), premultiply(), premultiply(), scale_cover(), to_double(), and transparent().

b

value_type agg::rgba16::b

Referenced by add(), apply_gamma_dir(), apply_gamma_inv(), clear(), demultiply(), demultiply(), gradient(), mult_cover(), multiply(), operator rgba(), operator rgba8(), operator srgba8(), premultiply(), premultiply(), and scale_cover().

g

value_type agg::rgba16::g

Referenced by add(), apply_gamma_dir(), apply_gamma_inv(), clear(), demultiply(), gradient(), operator rgba(), operator rgba8(), operator srgba8(), premultiply(), and premultiply().

r

value_type agg::rgba16::r

Referenced by add(), apply_gamma_dir(), apply_gamma_inv(), clear(), demultiply(), gradient(), operator rgba(), operator rgba8(), operator srgba8(), premultiply(), and premultiply().

---

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

• src/agg/agg_color_rgba.h