diff options
| author | Tobias Weimer <wishmaster51@googlemail.com> | 2015-07-12 14:10:16 +0000 |
|---|---|---|
| committer | Tobias Weimer <wishmaster51@googlemail.com> | 2015-07-12 14:10:16 +0000 |
| commit | f4ce2b5c214cce406dbd7a73dc7f35ae409546ad (patch) | |
| tree | 533cc821ffc9c5664c075930be6a40fde9593aba /plugins/Clist_ng/AGG/include/agg_scanline_u.h | |
| parent | 71a88c6d8c4578ca24e02a5c6f4860c206e7c6da (diff) | |
Clist NG:
Commit of CList NG by silvercircle from https://github.com/silvercircle/miranda-ng
This is based on clist_nicer and Anti-Grain Geometry: http://www.antigrain.com/
This is the first version that actually compiles.
Do NOT use it in production environment!
git-svn-id: http://svn.miranda-ng.org/main/trunk@14543 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c
Diffstat (limited to 'plugins/Clist_ng/AGG/include/agg_scanline_u.h')
| -rw-r--r-- | plugins/Clist_ng/AGG/include/agg_scanline_u.h | 508 |
1 files changed, 508 insertions, 0 deletions
diff --git a/plugins/Clist_ng/AGG/include/agg_scanline_u.h b/plugins/Clist_ng/AGG/include/agg_scanline_u.h new file mode 100644 index 0000000000..c3443b5f22 --- /dev/null +++ b/plugins/Clist_ng/AGG/include/agg_scanline_u.h @@ -0,0 +1,508 @@ +//----------------------------------------------------------------------------
+// Anti-Grain Geometry (AGG) - Version 2.5
+// A high quality rendering engine for C++
+// Copyright (C) 2002-2006 Maxim Shemanarev
+// Contact: mcseem@antigrain.com
+// mcseemagg@yahoo.com
+// http://antigrain.com
+//
+// AGG is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// AGG is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with AGG; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+// MA 02110-1301, USA.
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates (scanline32_u) has been sponsored by
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_SCANLINE_U_INCLUDED
+#define AGG_SCANLINE_U_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+ //=============================================================scanline_u8
+ //
+ // Unpacked scanline container class
+ //
+ // This class is used to transfer data from a scanline rasterizer
+ // to the rendering buffer. It's organized very simple. The class stores
+ // information of horizontal spans to render it into a pixel-map buffer.
+ // Each span has staring X, length, and an array of bytes that determine the
+ // cover-values for each pixel.
+ // Before using this class you should know the minimal and maximal pixel
+ // coordinates of your scanline. The protocol of using is:
+ // 1. reset(min_x, max_x)
+ // 2. add_cell() / add_span() - accumulate scanline.
+ // When forming one scanline the next X coordinate must be always greater
+ // than the last stored one, i.e. it works only with ordered coordinates.
+ // 3. Call finalize(y) and render the scanline.
+ // 3. Call reset_spans() to prepare for the new scanline.
+ //
+ // 4. Rendering:
+ //
+ // Scanline provides an iterator class that allows you to extract
+ // the spans and the cover values for each pixel. Be aware that clipping
+ // has not been done yet, so you should perform it yourself.
+ // Use scanline_u8::iterator to render spans:
+ //-------------------------------------------------------------------------
+ //
+ // int y = sl.y(); // Y-coordinate of the scanline
+ //
+ // ************************************
+ // ...Perform vertical clipping here...
+ // ************************************
+ //
+ // scanline_u8::const_iterator span = sl.begin();
+ //
+ // unsigned char* row = m_rbuf->row(y); // The the address of the beginning
+ // // of the current row
+ //
+ // unsigned num_spans = sl.num_spans(); // Number of spans. It's guaranteed that
+ // // num_spans is always greater than 0.
+ //
+ // do
+ // {
+ // const scanline_u8::cover_type* covers =
+ // span->covers; // The array of the cover values
+ //
+ // int num_pix = span->len; // Number of pixels of the span.
+ // // Always greater than 0, still it's
+ // // better to use "int" instead of
+ // // "unsigned" because it's more
+ // // convenient for clipping
+ // int x = span->x;
+ //
+ // **************************************
+ // ...Perform horizontal clipping here...
+ // ...you have x, covers, and pix_count..
+ // **************************************
+ //
+ // unsigned char* dst = row + x; // Calculate the start address of the row.
+ // // In this case we assume a simple
+ // // grayscale image 1-byte per pixel.
+ // do
+ // {
+ // *dst++ = *covers++; // Hypotetical rendering.
+ // }
+ // while(--num_pix);
+ //
+ // ++span;
+ // }
+ // while(--num_spans); // num_spans cannot be 0, so this loop is quite safe
+ //------------------------------------------------------------------------
+ //
+ // The question is: why should we accumulate the whole scanline when we
+ // could render just separate spans when they're ready?
+ // That's because using the scanline is generally faster. When is consists
+ // of more than one span the conditions for the processor cash system
+ // are better, because switching between two different areas of memory
+ // (that can be very large) occurs less frequently.
+ //------------------------------------------------------------------------
+ class scanline_u8
+ {
+ public:
+ typedef scanline_u8 self_type;
+ typedef int8u cover_type;
+ typedef int16 coord_type;
+
+ //--------------------------------------------------------------------
+ struct span
+ {
+ coord_type x;
+ coord_type len;
+ cover_type* covers;
+ };
+
+ typedef span* iterator;
+ typedef const span* const_iterator;
+
+ //--------------------------------------------------------------------
+ scanline_u8() :
+ m_min_x(0),
+ m_last_x(0x7FFFFFF0),
+ m_cur_span(0)
+ {}
+
+ //--------------------------------------------------------------------
+ void reset(int min_x, int max_x)
+ {
+ unsigned max_len = max_x - min_x + 2;
+ if(max_len > m_spans.size())
+ {
+ m_spans.resize(max_len);
+ m_covers.resize(max_len);
+ }
+ m_last_x = 0x7FFFFFF0;
+ m_min_x = min_x;
+ m_cur_span = &m_spans[0];
+ }
+
+ //--------------------------------------------------------------------
+ void add_cell(int x, unsigned cover)
+ {
+ x -= m_min_x;
+ m_covers[x] = (cover_type)cover;
+ if(x == m_last_x+1)
+ {
+ m_cur_span->len++;
+ }
+ else
+ {
+ m_cur_span++;
+ m_cur_span->x = (coord_type)(x + m_min_x);
+ m_cur_span->len = 1;
+ m_cur_span->covers = &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_cur_span->len += (coord_type)len;
+ }
+ else
+ {
+ m_cur_span++;
+ m_cur_span->x = (coord_type)(x + m_min_x);
+ m_cur_span->len = (coord_type)len;
+ m_cur_span->covers = &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_cur_span->len += (coord_type)len;
+ }
+ else
+ {
+ m_cur_span++;
+ m_cur_span->x = (coord_type)(x + m_min_x);
+ m_cur_span->len = (coord_type)len;
+ m_cur_span->covers = &m_covers[x];
+ }
+ m_last_x = x + len - 1;
+ }
+
+ //--------------------------------------------------------------------
+ void finalize(int y)
+ {
+ m_y = y;
+ }
+
+ //--------------------------------------------------------------------
+ void reset_spans()
+ {
+ m_last_x = 0x7FFFFFF0;
+ m_cur_span = &m_spans[0];
+ }
+
+ //--------------------------------------------------------------------
+ int y() const { return m_y; }
+ unsigned num_spans() const { return unsigned(m_cur_span - &m_spans[0]); }
+ const_iterator begin() const { return &m_spans[1]; }
+ iterator begin() { return &m_spans[1]; }
+
+ private:
+ scanline_u8(const self_type&);
+ const self_type& operator = (const self_type&);
+
+ private:
+ int m_min_x;
+ int m_last_x;
+ int m_y;
+ pod_array<cover_type> m_covers;
+ pod_array<span> m_spans;
+ span* m_cur_span;
+ };
+
+
+
+
+ //==========================================================scanline_u8_am
+ //
+ // The scanline container with alpha-masking
+ //
+ //------------------------------------------------------------------------
+ template<class AlphaMask>
+ class scanline_u8_am : public scanline_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;
+
+ 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() :
+ m_min_x(0),
+ m_last_x(0x7FFFFFF0),
+ m_covers()
+ {}
+
+ //--------------------------------------------------------------------
+ void reset(int min_x, int max_x)
+ {
+ unsigned max_len = max_x - min_x + 2;
+ if(max_len > m_covers.size())
+ {
+ m_covers.resize(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;
+ int m_last_x;
+ int m_y;
+ pod_array<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 scanline32_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
+
|