Clean up CPDF_AnnotList.
[pdfium.git] / third_party / agg23 / agg_rasterizer_scanline_aa.h
1
2 //----------------------------------------------------------------------------
3 // Anti-Grain Geometry - Version 2.3
4 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
5 //
6 // Permission to copy, use, modify, sell and distribute this software
7 // is granted provided this copyright notice appears in all copies.
8 // This software is provided "as is" without express or implied
9 // warranty, and with no claim as to its suitability for any purpose.
10 //
11 //----------------------------------------------------------------------------
12 //
13 // The author gratefully acknowleges the support of David Turner,
14 // Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
15 // libray - in producing this work. See http://www.freetype.org for details.
16 //
17 //----------------------------------------------------------------------------
18 // Contact: mcseem@antigrain.com
19 //          mcseemagg@yahoo.com
20 //          http://www.antigrain.com
21 //----------------------------------------------------------------------------
22 //
23 // Adaptation for 32-bit screen coordinates has been sponsored by
24 // Liberty Technology Systems, Inc., visit http://lib-sys.com
25 //
26 // Liberty Technology Systems, Inc. is the provider of
27 // PostScript and PDF technology for software developers.
28 //
29 //----------------------------------------------------------------------------
30 #ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
31 #define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
32 #include "../../core/include/fxge/fx_ge.h"
33 #include "agg_basics.h"
34 #include "agg_math.h"
35 #include "agg_array.h"
36 #include "agg_clip_liang_barsky.h"
37 #include "agg_render_scanlines.h"
38 namespace agg
39 {
40 enum poly_base_scale_e {
41     poly_base_shift = 8,
42     poly_base_size  = 1 << poly_base_shift,
43     poly_base_mask  = poly_base_size - 1
44 };
45 inline int poly_coord(FX_FLOAT c)
46 {
47     return int(c * poly_base_size);
48 }
49 struct cell_aa  {
50     int x;
51     int y;
52     int cover;
53     int area;
54     void set(int x, int y, int c, int a);
55     void set_coord(int x, int y);
56     void set_cover(int c, int a);
57     void add_cover(int c, int a);
58 };
59 class outline_aa 
60 {
61     enum cell_block_scale_e {
62         cell_block_shift = 12,
63         cell_block_size  = 1 << cell_block_shift,
64         cell_block_mask  = cell_block_size - 1,
65         cell_block_pool  = 256,
66         cell_block_limit = 1024
67     };
68     struct sorted_y  {
69         unsigned start;
70         unsigned num;
71     };
72 public:
73     ~outline_aa();
74     outline_aa();
75     void reset();
76     void move_to(int x, int y);
77     void line_to(int x, int y);
78     int min_x() const
79     {
80         return m_min_x;
81     }
82     int min_y() const
83     {
84         return m_min_y;
85     }
86     int max_x() const
87     {
88         return m_max_x;
89     }
90     int max_y() const
91     {
92         return m_max_y;
93     }
94     void sort_cells();
95     unsigned total_cells() const
96     {
97         return m_num_cells;
98     }
99     unsigned scanline_num_cells(unsigned y) const
100     {
101         return m_sorted_y[y - m_min_y].num;
102     }
103     const cell_aa* const* scanline_cells(unsigned y) const
104     {
105         return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start;
106     }
107     bool sorted() const
108     {
109         return m_sorted;
110     }
111 private:
112     outline_aa(const outline_aa&);
113     const outline_aa& operator = (const outline_aa&);
114     void set_cur_cell(int x, int y);
115     void add_cur_cell();
116     void render_hline(int ey, int x1, int y1, int x2, int y2);
117     void render_line(int x1, int y1, int x2, int y2);
118     void allocate_block();
119 private:
120     unsigned  m_num_blocks;
121     unsigned  m_max_blocks;
122     unsigned  m_cur_block;
123     unsigned  m_num_cells;
124     cell_aa** m_cells;
125     cell_aa*  m_cur_cell_ptr;
126     pod_array<cell_aa*> m_sorted_cells;
127     pod_array<sorted_y> m_sorted_y;
128     cell_aa   m_cur_cell;
129     int       m_cur_x;
130     int       m_cur_y;
131     int       m_min_x;
132     int       m_min_y;
133     int       m_max_x;
134     int       m_max_y;
135     bool      m_sorted;
136 };
137 class scanline_hit_test 
138 {
139 public:
140     scanline_hit_test(int x) : m_x(x), m_hit(false) {}
141     void reset_spans() {}
142     void finalize(int) {}
143     void add_cell(int x, int)
144     {
145         if(m_x == x) {
146             m_hit = true;
147         }
148     }
149     void add_span(int x, int len, int)
150     {
151         if(m_x >= x && m_x < x + len) {
152             m_hit = true;
153         }
154     }
155     unsigned num_spans() const
156     {
157         return 1;
158     }
159     bool hit() const
160     {
161         return m_hit;
162     }
163 private:
164     int  m_x;
165     bool m_hit;
166 };
167 enum filling_rule_e {
168     fill_non_zero,
169     fill_even_odd
170 };
171 class rasterizer_scanline_aa 
172 {
173     enum status {
174         status_initial,
175         status_line_to,
176         status_closed
177     };
178 public:
179     enum aa_scale_e {
180         aa_num   = 1 << 8,
181         aa_mask  = aa_num - 1,
182         aa_2num  = aa_num * 2,
183         aa_2mask = aa_2num - 1
184     };
185     rasterizer_scanline_aa() :
186         m_filling_rule(fill_non_zero),
187         m_clipped_start_x(0),
188         m_clipped_start_y(0),
189         m_status(status_initial),
190         m_clipping(false)
191     {
192     }
193     ~rasterizer_scanline_aa() {}
194     void filling_rule(filling_rule_e filling_rule)
195     {
196         m_filling_rule = filling_rule;
197     }
198     int min_x() const
199     {
200         return m_outline.min_x();
201     }
202     int min_y() const
203     {
204         return m_outline.min_y();
205     }
206     int max_x() const
207     {
208         return m_outline.max_x();
209     }
210     int max_y() const
211     {
212         return m_outline.max_y();
213     }
214     void reset()
215     {
216         m_outline.reset();
217         m_status = status_initial;
218     }
219     void clip_box(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2)
220     {
221         m_clip_box = rect(poly_coord(x1), poly_coord(y1),
222                           poly_coord(x2), poly_coord(y2));
223         m_clip_box.normalize();
224         m_clipping = true;
225     }
226     void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd)
227     {
228         if(is_close(cmd)) {
229             close_polygon();
230         } else {
231             if(is_move_to(cmd)) {
232                 move_to(poly_coord(x), poly_coord(y));
233             } else {
234                 if(is_vertex(cmd)) {
235                     line_to(poly_coord(x), poly_coord(y));
236                 }
237             }
238         }
239     }
240     void move_to(int x, int y)
241     {
242         if(m_clipping) {
243             if(m_outline.sorted()) {
244                 reset();
245             }
246             if(m_status == status_line_to) {
247                 close_polygon();
248             }
249             m_prev_x = m_start_x = x;
250             m_prev_y = m_start_y = y;
251             m_status = status_initial;
252             m_prev_flags = clipping_flags(x, y, m_clip_box);
253             if(m_prev_flags == 0) {
254                 move_to_no_clip(x, y);
255             }
256         } else {
257             move_to_no_clip(x, y);
258         }
259     }
260     void line_to(int x, int y)
261     {
262         if(m_clipping) {
263             clip_segment(x, y);
264         } else {
265             line_to_no_clip(x, y);
266         }
267     }
268     void close_polygon()
269     {
270         if (m_status != status_line_to) {
271             return;
272         }
273         if(m_clipping) {
274             clip_segment(m_start_x, m_start_y);
275         }
276         close_polygon_no_clip();
277     }
278     AGG_INLINE unsigned calculate_alpha(int area, bool no_smooth) const
279     {
280         int cover = area >> (poly_base_shift * 2 + 1 - 8);
281         if(cover < 0) {
282             cover = -cover;
283         }
284         if(m_filling_rule == fill_even_odd) {
285             cover &= aa_2mask;
286             if(cover > aa_num) {
287                 cover = aa_2num - cover;
288             }
289         }
290         if (no_smooth) {
291             cover = cover > aa_mask / 2 ? aa_mask : 0;
292         }
293         if(cover > aa_mask) {
294             cover = aa_mask;
295         }
296         return cover;
297     }
298     AGG_INLINE void sort()
299     {
300         m_outline.sort_cells();
301     }
302     AGG_INLINE bool rewind_scanlines()
303     {
304         close_polygon();
305         m_outline.sort_cells();
306         if(m_outline.total_cells() == 0) {
307             return false;
308         }
309         m_cur_y = m_outline.min_y();
310         return true;
311     }
312     AGG_INLINE bool navigate_scanline(int y)
313     {
314         close_polygon();
315         m_outline.sort_cells();
316         if(m_outline.total_cells() == 0 ||
317                 y < m_outline.min_y() ||
318                 y > m_outline.max_y()) {
319             return false;
320         }
321         m_cur_y = y;
322         return true;
323     }
324     template<class Scanline> bool sweep_scanline(Scanline& sl, bool no_smooth)
325     {
326         for(;;) {
327             if(m_cur_y > m_outline.max_y()) {
328                 return false;
329             }
330             sl.reset_spans();
331             unsigned num_cells = m_outline.scanline_num_cells(m_cur_y);
332             const cell_aa* const* cells = m_outline.scanline_cells(m_cur_y);
333             int cover = 0;
334             while(num_cells) {
335                 const cell_aa* cur_cell = *cells;
336                 int x    = cur_cell->x;
337                 int area = cur_cell->area;
338                 unsigned alpha;
339                 cover += cur_cell->cover;
340                 while(--num_cells) {
341                     cur_cell = *++cells;
342                     if(cur_cell->x != x) {
343                         break;
344                     }
345                     area  += cur_cell->area;
346                     cover += cur_cell->cover;
347                 }
348                 if(area) {
349                     alpha = calculate_alpha((cover << (poly_base_shift + 1)) - area, no_smooth);
350                     if(alpha) {
351                         sl.add_cell(x, alpha);
352                     }
353                     x++;
354                 }
355                 if(num_cells && cur_cell->x > x) {
356                     alpha = calculate_alpha(cover << (poly_base_shift + 1), no_smooth);
357                     if(alpha) {
358                         sl.add_span(x, cur_cell->x - x, alpha);
359                     }
360                 }
361             }
362             if(sl.num_spans()) {
363                 break;
364             }
365             ++m_cur_y;
366         }
367         sl.finalize(m_cur_y);
368         ++m_cur_y;
369         return true;
370     }
371     template<class VertexSource>
372     void add_path(VertexSource& vs, unsigned path_id = 0)
373     {
374         FX_FLOAT x;
375         FX_FLOAT y;
376         unsigned cmd;
377         vs.rewind(path_id);
378         while(!is_stop(cmd = vs.vertex(&x, &y))) {
379             add_vertex(x, y, cmd);
380         }
381     }
382     template<class VertexSource>
383     void add_path_transformed(VertexSource& vs, const CFX_AffineMatrix* pMatrix, unsigned path_id = 0)
384     {
385         FX_FLOAT x;
386         FX_FLOAT y;
387         unsigned cmd;
388         vs.rewind(path_id);
389         while(!is_stop(cmd = vs.vertex(&x, &y))) {
390             if (pMatrix) {
391                 pMatrix->Transform(x, y);
392             }
393             add_vertex(x, y, cmd);
394         }
395     }
396 private:
397     rasterizer_scanline_aa(const rasterizer_scanline_aa&);
398     const rasterizer_scanline_aa&
399     operator = (const rasterizer_scanline_aa&);
400     void move_to_no_clip(int x, int y)
401     {
402         if(m_status == status_line_to) {
403             close_polygon_no_clip();
404         }
405         m_outline.move_to(x * 1, y);
406         m_clipped_start_x = x;
407         m_clipped_start_y = y;
408         m_status = status_line_to;
409     }
410     void line_to_no_clip(int x, int y)
411     {
412         if(m_status != status_initial) {
413             m_outline.line_to(x * 1, y);
414             m_status = status_line_to;
415         }
416     }
417     void close_polygon_no_clip()
418     {
419         if(m_status == status_line_to) {
420             m_outline.line_to(m_clipped_start_x * 1, m_clipped_start_y);
421             m_status = status_closed;
422         }
423     }
424     void clip_segment(int x, int y)
425     {
426         unsigned flags = clipping_flags(x, y, m_clip_box);
427         if(m_prev_flags == flags) {
428             if(flags == 0) {
429                 if(m_status == status_initial) {
430                     move_to_no_clip(x, y);
431                 } else {
432                     line_to_no_clip(x, y);
433                 }
434             }
435         } else {
436             int cx[4];
437             int cy[4];
438             unsigned n = clip_liang_barsky(m_prev_x, m_prev_y,
439                                            x, y,
440                                            m_clip_box,
441                                            cx, cy);
442             const int* px = cx;
443             const int* py = cy;
444             while(n--) {
445                 if(m_status == status_initial) {
446                     move_to_no_clip(*px++, *py++);
447                 } else {
448                     line_to_no_clip(*px++, *py++);
449                 }
450             }
451         }
452         m_prev_flags = flags;
453         m_prev_x = x;
454         m_prev_y = y;
455     }
456 private:
457     outline_aa     m_outline;
458     filling_rule_e m_filling_rule;
459     int            m_clipped_start_x;
460     int            m_clipped_start_y;
461     int            m_start_x;
462     int            m_start_y;
463     int            m_prev_x;
464     int            m_prev_y;
465     unsigned       m_prev_flags;
466     unsigned       m_status;
467     rect           m_clip_box;
468     bool           m_clipping;
469     int            m_cur_y;
470 };
471 }
472 #endif