/*
 * Copyright 2014, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Copyright 2002-2004 Maxim Shemanarev (http://www.antigrain.com)
 *
 * Class clipped_alpha_mask, a modified version of alpha_mask_u8 that can
 * offset the mask, and has a controllable value for the area outside it.
 */

#ifndef AGG_CLIPED_ALPHA_MASK_INCLUDED
#define AGG_CLIPED_ALPHA_MASK_INCLUDED


#include <agg_alpha_mask_u8.h>
#include <agg_rendering_buffer.h>


namespace agg
{
        class clipped_alpha_mask
        {
                public:
                        typedef int8u cover_type;
                        enum cover_scale_e
                        {
                                cover_shift = 8,
                                cover_none  = 0,
                                cover_full  = 255
                        };

                        clipped_alpha_mask()
                                : m_xOffset(0), m_yOffset(0), m_rbuf(0), m_outside(0) {}
                        clipped_alpha_mask(rendering_buffer& rbuf)
                                : m_xOffset(0), m_yOffset(0), m_rbuf(&rbuf), m_outside(0) {}

                        void attach(rendering_buffer& rbuf)
                        {
                                m_rbuf = &rbuf;
                        }

                        void attach(rendering_buffer& rbuf, int x, int y, int8u outside)
                        {
                                m_rbuf = &rbuf;
                                m_xOffset = x;
                                m_yOffset = y;
                                m_outside = outside;
                        }

                        void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
                        {
                                int count = num_pix;
                                cover_type* covers = dst;

                                bool has_inside = _set_outside(x, y, covers, count);
                                if (!has_inside)
                                        return;

                                const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
                                do
                                {
                                        *covers = (cover_type)((cover_full + (*covers) * (*mask))
                                                >> cover_shift);
                                        ++covers;
                                        mask += Step;
                                }
                                while(--count);
                        }

                        void get_hspan(int x, int y, cover_type* dst, int num_pix) const
                        {
                                int count = num_pix;
                                cover_type* covers = dst;

                                bool has_inside = _set_outside(x, y, covers, count);
                                if (!has_inside)
                                        return;

                                const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
                                memcpy(covers, mask, count);
                        }

                private:
                        bool _set_outside(int& x, int& y, cover_type*& covers,
                                int& count) const
                        {
                                x -= m_xOffset;
                                y -= m_yOffset;

                                int xmax = m_rbuf->width() - 1;
                                int ymax = m_rbuf->height() - 1;

                                int num_pix = count;
                                cover_type* dst = covers;

                                if(y < 0 || y > ymax)
                                {
                                        memset(dst, m_outside, num_pix * sizeof(cover_type));
                                        return false;
                                }

                                if(x < 0)
                                {
                                        count += x;
                                        if(count <= 0)
                                        {
                                                memset(dst, m_outside, num_pix * sizeof(cover_type));
                                                return false;
                                        }
                                        memset(covers, m_outside, -x * sizeof(cover_type));
                                        covers -= x;
                                        x = 0;
                                }

                                if(x + count > xmax)
                                {
                                        int rest = x + count - xmax - 1;
                                        count -= rest;
                                        if(count <= 0)
                                        {
                                                memset(dst, m_outside, num_pix * sizeof(cover_type));
                                                return false;
                                        }
                                        memset(covers + count, m_outside, rest * sizeof(cover_type));
                                }

                                return true;
                        }


                private:
                        int m_xOffset;
                        int m_yOffset;

                        rendering_buffer* m_rbuf;
                        int8u m_outside;

                        static const int Step = 1;
                        static const int Offset = 0;
        };
}


#endif