agg_scanline_u.h

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

    {
    public:
        typedef scanline_u8           base_type;
        typedef AlphaMask             alpha_mask_type;
        typedef base_type::cover_type cover_type;
        typedef base_type::coord_type coord_type;

        scanline_u8_am() : base_type(), m_alpha_mask(0) {}
        scanline_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}

        //--------------------------------------------------------------------
        void finalize(int span_y)
        {
            base_type::finalize(span_y);
            if(m_alpha_mask)
            {
                typename base_type::iterator span = base_type::begin();
                unsigned count = base_type::num_spans();
                do
                {
                    m_alpha_mask->combine_hspan(span->x, 
                                                base_type::y(), 
                                                span->covers, 
                                                span->len);
                    ++span;
                }
                while(--count);
            }
        }

    private:
        const AlphaMask* m_alpha_mask;
    };




    //===========================================================scanline32_u8
    class scanline32_u8
    {
    public:
        typedef scanline32_u8 self_type;
        typedef int8u         cover_type;
        typedef int32         coord_type;

        //--------------------------------------------------------------------
        struct span
        {
            span() {}
            span(coord_type x_, coord_type len_, cover_type* covers_) :
                x(x_), len(len_), covers(covers_) {}

            coord_type  x;
            coord_type  len;
            cover_type* covers;
        };

        typedef pod_bvector<span, 4> span_array_type;

        //--------------------------------------------------------------------
        class const_iterator
        {
        public:
            const_iterator(const span_array_type& spans) :
                m_spans(spans),
                m_span_idx(0)
            {}

            const span& operator*()  const { return m_spans[m_span_idx];  }
            const span* operator->() const { return &m_spans[m_span_idx]; }

            void operator ++ () { ++m_span_idx; }

        private:
            const span_array_type& m_spans;
            unsigned               m_span_idx;
        };

        //--------------------------------------------------------------------
        class iterator
        {
        public:
            iterator(span_array_type& spans) :
                m_spans(spans),
                m_span_idx(0)
            {}

            span& operator*()  { return m_spans[m_span_idx];  }
            span* operator->() { return &m_spans[m_span_idx]; }

            void operator ++ () { ++m_span_idx; }

        private:
            span_array_type& m_spans;
            unsigned         m_span_idx;
        };



        //--------------------------------------------------------------------
        ~scanline32_u8()
        {
            delete [] m_covers;
        }

        scanline32_u8() :
            m_min_x(0),
            m_max_len(0),
            m_last_x(0x7FFFFFF0),
            m_covers(0)
        {}

        //--------------------------------------------------------------------
        void reset(int min_x, int max_x)
        {
            unsigned max_len = max_x - min_x + 2;
            if(max_len > m_max_len)
            {
                delete [] m_covers;
                m_covers  = new cover_type [max_len];
                m_max_len = max_len;
            }
            m_last_x = 0x7FFFFFF0;
            m_min_x  = min_x;
            m_spans.remove_all();
        }

        //--------------------------------------------------------------------
        void add_cell(int x, unsigned cover)
        {
            x -= m_min_x;
            m_covers[x] = cover_type(cover);
            if(x == m_last_x+1)
            {
                m_spans.last().len++;
            }
            else
            {
                m_spans.add(span(coord_type(x + m_min_x), 1, m_covers + x));
            }
            m_last_x = x;
        }

        //--------------------------------------------------------------------
        void add_cells(int x, unsigned len, const cover_type* covers)
        {
            x -= m_min_x;
            memcpy(m_covers + x, covers, len * sizeof(cover_type));
            if(x == m_last_x+1)
            {
                m_spans.last().len += coord_type(len);
            }
            else
            {
                m_spans.add(span(coord_type(x + m_min_x), coord_type(len), m_covers + x));
            }
            m_last_x = x + len - 1;
        }

        //--------------------------------------------------------------------
        void add_span(int x, unsigned len, unsigned cover)
        {
            x -= m_min_x;
            memset(m_covers + x, cover, len);
            if(x == m_last_x+1)
            {
                m_spans.last().len += coord_type(len);
            }
            else
            {
                m_spans.add(span(coord_type(x + m_min_x), coord_type(len), m_covers + x));
            }
            m_last_x = x + len - 1;
        }

        //--------------------------------------------------------------------
        void finalize(int y) 
        { 
            m_y = y; 
        }

        //--------------------------------------------------------------------
        void reset_spans()
        {
            m_last_x = 0x7FFFFFF0;
            m_spans.remove_all();
        }

        //--------------------------------------------------------------------
        int      y()           const { return m_y; }
        unsigned num_spans()   const { return m_spans.size(); }
        const_iterator begin() const { return const_iterator(m_spans); }
        iterator       begin()       { return iterator(m_spans); }

    private:
        scanline32_u8(const self_type&);
        const self_type& operator = (const self_type&);

    private:
        int             m_min_x;
        unsigned        m_max_len;
        int             m_last_x;
        int             m_y;
        cover_type*     m_covers;
        span_array_type m_spans;
    };




    //========================================================scanline32_u8_am
    // 
    // The scanline container with alpha-masking
    // 
    //------------------------------------------------------------------------
    template<class AlphaMask> 
    class scanline32_u8_am : public scanline32_u8
    {
    public:
        typedef scanline_u8           base_type;
        typedef AlphaMask             alpha_mask_type;
        typedef base_type::cover_type cover_type;
        typedef base_type::coord_type coord_type;


        scanline32_u8_am() : base_type(), m_alpha_mask(0) {}
        scanline32_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}

        //--------------------------------------------------------------------
        void finalize(int span_y)
        {
            base_type::finalize(span_y);
            if(m_alpha_mask)
            {
                typename base_type::iterator span = base_type::begin();
                unsigned count = base_type::num_spans();
                do
                {
                    m_alpha_mask->combine_hspan(span->x, 
                                                base_type::y(), 
                                                span->covers, 
                                                span->len);
                    ++span;
                }
                while(--count);
            }
        }

    private:
        const AlphaMask* m_alpha_mask;
    };



}

#endif