agg::pixfmt_srgb24_gamma< Gamma > Class Template Reference

#include <src/agg/agg_pixfmt_rgb.h>

Inheritance diagram for agg::pixfmt_srgb24_gamma< Gamma >:

Collaboration diagram for agg::pixfmt_srgb24_gamma< Gamma >:

Public Types
enum
typedef pixfmt_rgb_tag	pixfmt_category
typedef rendering_buffer	rbuf_type
typedef blender_rgb_gamma< srgba8, order_rgb, Gamma >	blender_type
typedef rbuf_type::row_data	row_data
typedef blender_type::color_type	color_type
typedef blender_type::order_type	order_type
typedef color_type::value_type	value_type
typedef color_type::calc_type	calc_type

Public Member Functions
	pixfmt_srgb24_gamma (rendering_buffer &rb, const Gamma &g)
void	attach (rbuf_type &rb)
bool	attach (PixFmt &pixf, int x1, int y1, int x2, int y2)
blender_rgb_gamma< srgba8, order_rgb, Gamma > &	blender ()
AGG_INLINE unsigned	width () const
AGG_INLINE unsigned	height () const
AGG_INLINE int	stride () const
AGG_INLINE int8u *	row_ptr (int y)
AGG_INLINE const int8u *	row_ptr (int y) const
AGG_INLINE row_data	row (int y) const
AGG_INLINE int8u *	pix_ptr (int x, int y)
AGG_INLINE const int8u *	pix_ptr (int x, int y) const
AGG_INLINE pixel_type *	pix_value_ptr (int x, int y, unsigned len)
AGG_INLINE const pixel_type *	pix_value_ptr (int x, int y) const
AGG_INLINE color_type	pixel (int x, int y) const
AGG_INLINE void	copy_pixel (int x, int y, const color_type &c)
AGG_INLINE void	blend_pixel (int x, int y, const color_type &c, int8u cover)
AGG_INLINE void	copy_hline (int x, int y, unsigned len, const color_type &c)
AGG_INLINE void	copy_vline (int x, int y, unsigned len, const color_type &c)
void	blend_hline (int x, int y, unsigned len, const color_type &c, int8u cover)
void	blend_vline (int x, int y, unsigned len, const color_type &c, int8u cover)
void	blend_solid_hspan (int x, int y, unsigned len, const color_type &c, const int8u *covers)
void	blend_solid_vspan (int x, int y, unsigned len, const color_type &c, const int8u *covers)
void	copy_color_hspan (int x, int y, unsigned len, const color_type *colors)
void	copy_color_vspan (int x, int y, unsigned len, const color_type *colors)
void	blend_color_hspan (int x, int y, unsigned len, const color_type *colors, const int8u *covers, int8u cover)
void	blend_color_vspan (int x, int y, unsigned len, const color_type *colors, const int8u *covers, int8u cover)
void	for_each_pixel (Function f)
void	apply_gamma_dir (const GammaLut &g)
void	apply_gamma_inv (const GammaLut &g)
void	copy_from (const RenBuf2 &from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
void	blend_from (const SrcPixelFormatRenderer &from, int xdst, int ydst, int xsrc, int ysrc, unsigned len, int8u cover)
void	blend_from_color (const SrcPixelFormatRenderer &from, const color_type &color, int xdst, int ydst, int xsrc, int ysrc, unsigned len, int8u cover)
void	blend_from_lut (const SrcPixelFormatRenderer &from, const color_type *color_lut, int xdst, int ydst, int xsrc, int ysrc, unsigned len, int8u cover)

Static Public Member Functions
static AGG_INLINE pixel_type *	pix_value_ptr (void *p)
static AGG_INLINE const pixel_type *	pix_value_ptr (const void *p)
static AGG_INLINE void	write_plain_color (void *p, color_type c)
static AGG_INLINE color_type	read_plain_color (const void *p)
static AGG_INLINE void	make_pix (int8u *p, const color_type &c)

Private Member Functions
AGG_INLINE void	blend_pix (pixel_type *p, value_type r, value_type g, value_type b, value_type a, unsigned cover)
AGG_INLINE void	blend_pix (pixel_type *p, value_type r, value_type g, value_type b, value_type a)
AGG_INLINE void	blend_pix (pixel_type *p, const color_type &c, unsigned cover)
AGG_INLINE void	blend_pix (pixel_type *p, const color_type &c)
AGG_INLINE void	copy_or_blend_pix (pixel_type *p, const color_type &c, unsigned cover)
AGG_INLINE void	copy_or_blend_pix (pixel_type *p, const color_type &c)

Private Attributes
rbuf_type *	m_rbuf
blender_rgb_gamma< srgba8, order_rgb, Gamma >	m_blender

Detailed Description

template<class Gamma>
class agg::pixfmt_srgb24_gamma< Gamma >

Member Typedef Documentation

blender_type

typedef blender_rgb_gamma< srgba8, order_rgb, Gamma > agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blender_type

inherited

calc_type

typedef color_type::calc_type agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::calc_type

inherited

color_type

typedef blender_type::color_type agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::color_type

inherited

order_type

typedef blender_type::order_type agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::order_type

inherited

pixfmt_category

typedef pixfmt_rgb_tag agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pixfmt_category

inherited

rbuf_type

typedef rendering_buffer agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::rbuf_type

inherited

row_data

typedef rbuf_type::row_data agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::row_data

inherited

value_type

typedef color_type::value_type agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::value_type

inherited

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

        {
            num_components = 3,
            pix_step = Step,
            pix_offset = Offset,
            pix_width = sizeof(value_type) * pix_step
        };

Constructor & Destructor Documentation

pixfmt_srgb24_gamma()

template<class Gamma >

agg::pixfmt_srgb24_gamma< Gamma >::pixfmt_srgb24_gamma ( rendering_buffer &  rb, const Gamma &  g  )

inline

                                                                  :
            pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
        {
            this->blender().gamma(g);
        }

References agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma >, rendering_buffer, 3 >::blender(), and agg::blender_rgb_gamma< ColorT, Order, Gamma >::gamma().

Here is the call graph for this function:

Member Function Documentation

apply_gamma_dir()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::apply_gamma_dir ( const GammaLut &  g )

inlineinherited

        {
            for_each_pixel(apply_gamma_dir_rgb<color_type, order_type, GammaLut>(g));
        }

apply_gamma_inv()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::apply_gamma_inv ( const GammaLut &  g )

inlineinherited

        {
            for_each_pixel(apply_gamma_inv_rgb<color_type, order_type, GammaLut>(g));
        }

attach() [1/2]

bool agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::attach ( PixFmt &  pixf, int  x1, int  y1, int  x2, int  y2  )

inlineinherited

        {
            rect_i r(x1, y1, x2, y2);
            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
            {
                int stride = pixf.stride();
                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
                               (r.x2 - r.x1) + 1,
                               (r.y2 - r.y1) + 1,
                               stride);
                return true;
            }
            return false;
        }

attach() [2/2]

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::attach ( rbuf_type &  rb )

inlineinherited

{ m_rbuf = &rb; }

blend_color_hspan()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_color_hspan ( int  x, int  y, unsigned  len, const color_type *  colors, const int8u *  covers, int8u  cover  )

inlineinherited

        {
            pixel_type* p = pix_value_ptr(x, y, len);
 
            if (covers)
            {
                do 
                {
                    copy_or_blend_pix(p, *colors++, *covers++);
                    p = p->next();
                }
                while (--len);
            }
            else
            {
                if (cover == cover_mask)
                {
                    do 
                    {
                        copy_or_blend_pix(p, *colors++);
                        p = p->next();
                    }
                    while (--len);
                }
                else
                {
                    do 
                    {
                        copy_or_blend_pix(p, *colors++, cover);
                        p = p->next();
                    }
                    while (--len);
                }
            }
        }

blend_color_vspan()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_color_vspan ( int  x, int  y, unsigned  len, const color_type *  colors, const int8u *  covers, int8u  cover  )

inlineinherited

        {
            if (covers)
            {
                do 
                {
                    copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
                }
                while (--len);
            }
            else
            {
                if (cover == cover_mask)
                {
                    do 
                    {
                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
                    }
                    while (--len);
                }
                else
                {
                    do 
                    {
                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
                    }
                    while (--len);
                }
            }
        }

blend_from()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_from ( const SrcPixelFormatRenderer &  from, int  xdst, int  ydst, int  xsrc, int  ysrc, unsigned  len, int8u  cover  )

inlineinherited

        {
            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
            typedef typename SrcPixelFormatRenderer::order_type src_order;
 
            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
            {
                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
 
                if (cover == cover_mask)
                {
                    do 
                    {
                        value_type alpha = psrc->c[src_order::A];
                        if (alpha <= color_type::empty_value())
                        {
                            if (alpha >= color_type::full_value())
                            {
                                pdst->c[order_type::R] = psrc->c[src_order::R];
                                pdst->c[order_type::G] = psrc->c[src_order::G];
                                pdst->c[order_type::B] = psrc->c[src_order::B];
                            }
                            else
                            {
                                blend_pix(pdst, 
                                    psrc->c[src_order::R],
                                    psrc->c[src_order::G],
                                    psrc->c[src_order::B],
                                    alpha);
                            }
                        }
                        psrc = psrc->next();
                        pdst = pdst->next();
                    }
                    while(--len);
                }
                else
                {
                    do 
                    {
                        copy_or_blend_pix(pdst, psrc->get(), cover);
                        psrc = psrc->next();
                        pdst = pdst->next();
                    }
                    while (--len);
                }
            }
        }

blend_from_color()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_from_color ( const SrcPixelFormatRenderer &  from, const color_type &  color, int  xdst, int  ydst, int  xsrc, int  ysrc, unsigned  len, int8u  cover  )

inlineinherited

        {
            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
 
            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
            {
                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
 
                do 
                {
                    copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
                    psrc = psrc->next();
                    pdst = pdst->next();
                }
                while (--len);
            }
        }

blend_from_lut()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_from_lut ( const SrcPixelFormatRenderer &  from, const color_type *  color_lut, int  xdst, int  ydst, int  xsrc, int  ysrc, unsigned  len, int8u  cover  )

inlineinherited

        {
            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
 
            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
            {
                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
 
                if (cover == cover_mask)
                {
                    do 
                    {
                        const color_type& color = color_lut[psrc->c[0]];
                        blend_pix(pdst, color);
                        psrc = psrc->next();
                        pdst = pdst->next();
                    }
                    while(--len);
                }
                else
                {
                    do 
                    {
                        copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
                        psrc = psrc->next();
                        pdst = pdst->next();
                    }
                    while(--len);
                }
            }
        }

blend_hline()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_hline ( int  x, int  y, unsigned  len, const color_type &  c, int8u  cover  )

inlineinherited

        {
            if (!c.is_transparent())
            {
                pixel_type* p = pix_value_ptr(x, y, len);
 
                if (c.is_opaque() && cover == cover_mask)
                {
                    do
                    {
                        p->set(c);
                        p = p->next();
                    }
                    while (--len);
                }
                else
                {
                    do
                    {
                        blend_pix(p, c, cover);
                        p = p->next();
                    }
                    while (--len);
                }
            }
        }

blend_pix() [1/4]

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_pix ( pixel_type *  p, const color_type &  c  )

inlineprivateinherited

        {
            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a);
        }

blend_pix() [2/4]

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_pix ( pixel_type *  p, const color_type &  c, unsigned  cover  )

inlineprivateinherited

        {
            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a, cover);
        }

blend_pix() [3/4]

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_pix ( pixel_type *  p, value_type  r, value_type  g, value_type  b, value_type  a  )

inlineprivateinherited

        {
            m_blender.blend_pix(p->c, r, g, b, a);
        }

blend_pix() [4/4]

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_pix ( pixel_type *  p, value_type  r, value_type  g, value_type  b, value_type  a, unsigned  cover  )

inlineprivateinherited

        {
            m_blender.blend_pix(p->c, r, g, b, a, cover);
        }

blend_pixel()

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_pixel ( int  x, int  y, const color_type &  c, int8u  cover  )

inlineinherited

        {
            copy_or_blend_pix(pix_value_ptr(x, y, 1), c, cover);
        }

blend_solid_hspan()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_solid_hspan ( int  x, int  y, unsigned  len, const color_type &  c, const int8u *  covers  )

inlineinherited

        {
            if (!c.is_transparent())
            {
                pixel_type* p = pix_value_ptr(x, y, len);
 
                do 
                {
                    if (c.is_opaque() && *covers == cover_mask)
                    {
                        p->set(c);
                    }
                    else
                    {
                        blend_pix(p, c, *covers);
                    }
                    p = p->next();
                    ++covers;
                }
                while (--len);
            }
        }

blend_solid_vspan()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_solid_vspan ( int  x, int  y, unsigned  len, const color_type &  c, const int8u *  covers  )

inlineinherited

        {
            if (!c.is_transparent())
            {
                do 
                {
                    pixel_type* p = pix_value_ptr(x, y++, 1);
 
                    if (c.is_opaque() && *covers == cover_mask)
                    {
                        p->set(c);
                    }
                    else
                    {
                        blend_pix(p, c, *covers);
                    }
                    ++covers;
                }
                while (--len);
            }
        }

blend_vline()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blend_vline ( int  x, int  y, unsigned  len, const color_type &  c, int8u  cover  )

inlineinherited

        {
            if (!c.is_transparent())
            {
                if (c.is_opaque() && cover == cover_mask)
                {
                    do
                    {
                        pix_value_ptr(x, y++, 1)->set(c);
                    }
                    while (--len);
                }
                else
                {
                    do
                    {
                        blend_pix(pix_value_ptr(x, y++, 1), c, cover);
                    }
                    while (--len);
                }
            }
        }

blender()

blender_rgb_gamma< srgba8, order_rgb, Gamma > & agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::blender ( )

inlineinherited

{ return m_blender; }

copy_color_hspan()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_color_hspan ( int  x, int  y, unsigned  len, const color_type *  colors  )

inlineinherited

        {
            pixel_type* p = pix_value_ptr(x, y, len);
 
            do 
            {
                p->set(*colors++);
                p = p->next();
            }
            while (--len);
        }

copy_color_vspan()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_color_vspan ( int  x, int  y, unsigned  len, const color_type *  colors  )

inlineinherited

        {
            do 
            {
                pix_value_ptr(x, y++, 1)->set(*colors++);
            }
            while (--len);
        }

copy_from()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_from ( const RenBuf2 &  from, int  xdst, int  ydst, int  xsrc, int  ysrc, unsigned  len  )

inlineinherited

        {
            if (const int8u* p = from.row_ptr(ysrc))
            {
                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
                        p + xsrc * pix_width, 
                        len * pix_width);
            }
        }

copy_hline()

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_hline ( int  x, int  y, unsigned  len, const color_type &  c  )

inlineinherited

        {
            pixel_type* p = pix_value_ptr(x, y, len);
            do
            {
                p->set(c);
                p = p->next();
            }
            while(--len);
        }

copy_or_blend_pix() [1/2]

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_or_blend_pix ( pixel_type *  p, const color_type &  c  )

inlineprivateinherited

        {
            if (!c.is_transparent())
            {
                if (c.is_opaque())
                {
                    p->set(c);
                }
                else
                {
                    blend_pix(p, c);
                }
            }
        }

copy_or_blend_pix() [2/2]

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_or_blend_pix ( pixel_type *  p, const color_type &  c, unsigned  cover  )

inlineprivateinherited

        {
            if (!c.is_transparent())
            {
                if (c.is_opaque() && cover == cover_mask)
                {
                    p->set(c);
                }
                else
                {
                    blend_pix(p, c, cover);
                }
            }
        }

copy_pixel()

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_pixel ( int  x, int  y, const color_type &  c  )

inlineinherited

        {
            pix_value_ptr(x, y, 1)->set(c);
        }

copy_vline()

AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::copy_vline ( int  x, int  y, unsigned  len, const color_type &  c  )

inlineinherited

        {
            do
            {
                pix_value_ptr(x, y++, 1)->set(c);
            }
            while (--len);
        }

for_each_pixel()

void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::for_each_pixel ( Function  f )

inlineinherited

        {
            for (unsigned y = 0; y < height(); ++y)
            {
                row_data r = m_rbuf->row(y);
                if (r.ptr)
                {
                    unsigned len = r.x2 - r.x1 + 1;
                    pixel_type* p = pix_value_ptr(r.x1, y, len);
                    do
                    {
                        f(p->c);
                        p = p->next();
                    }
                    while (--len);
                }
            }
        }

height()

AGG_INLINE unsigned agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::height ( ) const

inlineinherited

{ return m_rbuf->height(); }

make_pix()

static AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::make_pix ( int8u *  p, const color_type &  c  )

inlinestaticinherited

        {
            ((pixel_type*)p)->set(c);
        }

pix_ptr() [1/2]

AGG_INLINE int8u * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pix_ptr ( int  x, int  y  )

inlineinherited

        { 
            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
        }

pix_ptr() [2/2]

AGG_INLINE const int8u * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pix_ptr ( int  x, int  y  ) const

inlineinherited

        { 
            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
        }

pix_value_ptr() [1/4]

static AGG_INLINE const pixel_type * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pix_value_ptr ( const void *  p )

inlinestaticinherited

        {
            return (const pixel_type*)((const value_type*)p + pix_offset);
        }

pix_value_ptr() [2/4]

AGG_INLINE const pixel_type * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pix_value_ptr ( int  x, int  y  ) const

inlineinherited

        {
            int8u* p = m_rbuf->row_ptr(y);
            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step + pix_offset)) : 0;
        }

pix_value_ptr() [3/4]

AGG_INLINE pixel_type * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pix_value_ptr ( int  x, int  y, unsigned  len  )

inlineinherited

        {
            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step + pix_offset));
        }

pix_value_ptr() [4/4]

static AGG_INLINE pixel_type * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pix_value_ptr ( void *  p )

inlinestaticinherited

        {
            return (pixel_type*)((value_type*)p + pix_offset);
        }

pixel()

AGG_INLINE color_type agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::pixel ( int  x, int  y  ) const

inlineinherited

        {
            if (const pixel_type* p = pix_value_ptr(x, y))
            {
                return p->get();
            }
            return color_type::no_color();
        }

read_plain_color()

static AGG_INLINE color_type agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::read_plain_color ( const void *  p )

inlinestaticinherited

        {
            return pix_value_ptr(p)->get();
        }

row()

AGG_INLINE row_data agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::row ( int  y ) const

inlineinherited

{ return m_rbuf->row(y); }

row_ptr() [1/2]

AGG_INLINE int8u * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::row_ptr ( int  y )

inlineinherited

{ return m_rbuf->row_ptr(y); }

row_ptr() [2/2]

AGG_INLINE const int8u * agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::row_ptr ( int  y ) const

inlineinherited

{ return m_rbuf->row_ptr(y); }

stride()

AGG_INLINE int agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::stride ( ) const

inlineinherited

{ return m_rbuf->stride(); }

width()

AGG_INLINE unsigned agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::width ( ) const

inlineinherited

{ return m_rbuf->width();  }

write_plain_color()

static AGG_INLINE void agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::write_plain_color ( void *  p, color_type  c  )

inlinestaticinherited

        {
            // RGB formats are implicitly premultiplied.
            c.premultiply();
            pix_value_ptr(p)->set(c);
        }

Member Data Documentation

m_blender

blender_rgb_gamma< srgba8, order_rgb, Gamma > agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::m_blender

privateinherited

m_rbuf

rbuf_type* agg::pixfmt_alpha_blend_rgb< blender_rgb_gamma< srgba8, order_rgb, Gamma > , rendering_buffer , Step, 0 >::m_rbuf

privateinherited

---

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

• src/agg/agg_pixfmt_rgb.h