agg_pixfmt_rgba32.h

来自「这是VCF框架的代码」· C头文件 代码 · 共 438 行 · 第 1/2 页

            {
                int alpha = int(*covers++) * c.a;

                if(alpha)
                {
                    if(alpha == 255*255)
                    {
                        p[Order::R] = (int8u)c.r;
                        p[Order::G] = (int8u)c.g;
                        p[Order::B] = (int8u)c.b;
                        p[Order::A] = (int8u)c.a;
                    }
                    else
                    {
                        int r = p[Order::R];
                        int g = p[Order::G];
                        int b = p[Order::B];
                        int a = p[Order::A];
                        p[Order::R] = (int8u)((((c.r - r) * alpha) + (r << 16)) >> 16);
                        p[Order::G] = (int8u)((((c.g - g) * alpha) + (g << 16)) >> 16);
                        p[Order::B] = (int8u)((((c.b - b) * alpha) + (b << 16)) >> 16);
                        p[Order::A] = (int8u)(((alpha + (a << 8)) - ((alpha * a) >> 8)) >> 8);
                    }
                }
                p += 4;
            }
            while(--len);
        }



        //--------------------------------------------------------------------
        void blend_solid_vspan(int x, int y, unsigned len, 
                               const color_type& c, const int8u* covers)
        {
            int8u* p = m_rbuf->row(y) + (x << 2);
            do 
            {
                int alpha = int(*covers++) * c.a;

                if(alpha)
                {
                    if(alpha == 255*255)
                    {
                        p[Order::R] = (int8u)c.r;
                        p[Order::G] = (int8u)c.g;
                        p[Order::B] = (int8u)c.b;
                        p[Order::A] = (int8u)c.a;
                    }
                    else
                    {
                        int r = p[Order::R];
                        int g = p[Order::G];
                        int b = p[Order::B];
                        int a = p[Order::A];
                        p[Order::R] = (int8u)((((c.r - r) * alpha) + (r << 16)) >> 16);
                        p[Order::G] = (int8u)((((c.g - g) * alpha) + (g << 16)) >> 16);
                        p[Order::B] = (int8u)((((c.b - b) * alpha) + (b << 16)) >> 16);
                        p[Order::A] = (int8u)(((alpha + (a << 8)) - ((alpha * a) >> 8)) >> 8);
                    }
                }
                p += m_rbuf->stride();
            }
            while(--len);
        }


        //--------------------------------------------------------------------
        void blend_color_hspan(int x, int y, unsigned len, 
                               const color_type* colors, const int8u* covers)
        {
            int8u* p = m_rbuf->row(y) + (x << 2);
            if(covers)
            {
                do 
                {
                    int alpha = int(*covers++) * colors->a;

                    if(alpha)
                    {
                        if(alpha == 255*255)
                        {
                            p[Order::R] = (int8u)colors->r;
                            p[Order::G] = (int8u)colors->g;
                            p[Order::B] = (int8u)colors->b;
                            p[Order::A] = (int8u)colors->a;
                        }
                        else
                        {
                            int r = p[Order::R];
                            int g = p[Order::G];
                            int b = p[Order::B];
                            int a = p[Order::A];
                            p[Order::R] = (int8u)((((colors->r - r) * alpha) + (r << 16)) >> 16);
                            p[Order::G] = (int8u)((((colors->g - g) * alpha) + (g << 16)) >> 16);
                            p[Order::B] = (int8u)((((colors->b - b) * alpha) + (b << 16)) >> 16);
                            p[Order::A] = (int8u)(((alpha + (a << 8)) - ((alpha * a) >> 8)) >> 8);
                        }
                    }
                    p += 4;
                    ++colors;
                }
                while(--len);
            }
            else
            {
                do 
                {
                    if(colors->a)
                    {
                        if(colors->a == 255)
                        {
                            p[Order::R] = (int8u)colors->r;
                            p[Order::G] = (int8u)colors->g;
                            p[Order::B] = (int8u)colors->b;
                            p[Order::A] = (int8u)colors->a;
                        }
                        else
                        {
                            int r = p[Order::R];
                            int g = p[Order::G];
                            int b = p[Order::B];
                            int a = p[Order::A];
                            p[Order::R] = (int8u)((((colors->r - r) * colors->a) + (r << 8)) >> 8);
                            p[Order::G] = (int8u)((((colors->g - g) * colors->a) + (g << 8)) >> 8);
                            p[Order::B] = (int8u)((((colors->b - b) * colors->a) + (b << 8)) >> 8);
                            p[Order::A] = (int8u)((((colors->a + a) << 8) - colors->a * a) >> 8);
                        }
                    }
                    p += 4;
                    ++colors;
                }
                while(--len);
            }
        }


        //--------------------------------------------------------------------
        void blend_color_vspan(int x, int y, unsigned len, 
                               const color_type* colors, const int8u* covers)
        {
            int8u* p = m_rbuf->row(y) + (x << 2);
            if(covers)
            {
                do 
                {
                    int alpha = int(*covers++) * colors->a;

                    if(alpha)
                    {
                        if(alpha == 255*255)
                        {
                            p[Order::R] = (int8u)colors->r;
                            p[Order::G] = (int8u)colors->g;
                            p[Order::B] = (int8u)colors->b;
                            p[Order::A] = (int8u)colors->a;
                        }
                        else
                        {
                            int r = p[Order::R];
                            int g = p[Order::G];
                            int b = p[Order::B];
                            int a = p[Order::A];
                            p[Order::R] = (int8u)((((colors->r - r) * alpha) + (r << 16)) >> 16);
                            p[Order::G] = (int8u)((((colors->g - g) * alpha) + (g << 16)) >> 16);
                            p[Order::B] = (int8u)((((colors->b - b) * alpha) + (b << 16)) >> 16);
                            p[Order::A] = (int8u)(((alpha + (a << 8)) - ((alpha * a) >> 8)) >> 8);
                        }
                    }
                    p += m_rbuf->stride();
                    ++colors;
                }
                while(--len);
            }
            else
            {
                do 
                {
                    if(colors->a)
                    {
                        if(colors->a == 255)
                        {
                            p[Order::R] = (int8u)colors->r;
                            p[Order::G] = (int8u)colors->g;
                            p[Order::B] = (int8u)colors->b;
                            p[Order::A] = (int8u)colors->a;
                        }
                        else
                        {
                            int r = p[Order::R];
                            int g = p[Order::G];
                            int b = p[Order::B];
                            int a = p[Order::A];
                            p[Order::R] = (int8u)((((colors->r - r) * colors->a) + (r << 8)) >> 8);
                            p[Order::G] = (int8u)((((colors->g - g) * colors->a) + (g << 8)) >> 8);
                            p[Order::B] = (int8u)((((colors->b - b) * colors->a) + (b << 8)) >> 8);
                            p[Order::A] = (int8u)((((colors->a + a) << 8) - colors->a * a) >> 8);
                        }
                    }
                    p += m_rbuf->stride();
                    ++colors;
                }
                while(--len);
            }
        }

    private:
        rendering_buffer* m_rbuf;
    };

    typedef pixel_formats_rgba32<order_rgba32> pixfmt_rgba32; //----pixfmt_rgba32
    typedef pixel_formats_rgba32<order_argb32> pixfmt_argb32; //----pixfmt_argb32
    typedef pixel_formats_rgba32<order_abgr32> pixfmt_abgr32; //----pixfmt_abgr32
    typedef pixel_formats_rgba32<order_bgra32> pixfmt_bgra32; //----pixfmt_bgra32
}

#endif