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 "../../../../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 };
poly_coord(FX_FLOAT c)45 inline int poly_coord(FX_FLOAT c)
46 {
47 return int(c * poly_base_size);
48 }
49 struct cell_aa : public CFX_Object {
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 : public CFX_Object
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 : public CFX_Object {
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);
min_x()78 int min_x() const
79 {
80 return m_min_x;
81 }
min_y()82 int min_y() const
83 {
84 return m_min_y;
85 }
max_x()86 int max_x() const
87 {
88 return m_max_x;
89 }
max_y()90 int max_y() const
91 {
92 return m_max_y;
93 }
94 void sort_cells();
total_cells()95 unsigned total_cells() const
96 {
97 return m_num_cells;
98 }
scanline_num_cells(unsigned y)99 unsigned scanline_num_cells(unsigned y) const
100 {
101 return m_sorted_y[y - m_min_y].num;
102 }
scanline_cells(unsigned y)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 }
sorted()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 : public CFX_Object
138 {
139 public:
scanline_hit_test(int x)140 scanline_hit_test(int x) : m_x(x), m_hit(false) {}
reset_spans()141 void reset_spans() {}
finalize(int)142 void finalize(int) {}
add_cell(int x,int)143 void add_cell(int x, int)
144 {
145 if(m_x == x) {
146 m_hit = true;
147 }
148 }
add_span(int x,int len,int)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 }
num_spans()155 unsigned num_spans() const
156 {
157 return 1;
158 }
hit()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 : public CFX_Object
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 };
rasterizer_scanline_aa()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 }
~rasterizer_scanline_aa()193 ~rasterizer_scanline_aa() {}
filling_rule(filling_rule_e filling_rule)194 void filling_rule(filling_rule_e filling_rule)
195 {
196 m_filling_rule = filling_rule;
197 }
min_x()198 int min_x() const
199 {
200 return m_outline.min_x();
201 }
min_y()202 int min_y() const
203 {
204 return m_outline.min_y();
205 }
max_x()206 int max_x() const
207 {
208 return m_outline.max_x();
209 }
max_y()210 int max_y() const
211 {
212 return m_outline.max_y();
213 }
reset()214 void reset()
215 {
216 m_outline.reset();
217 m_status = status_initial;
218 }
clip_box(FX_FLOAT x1,FX_FLOAT y1,FX_FLOAT x2,FX_FLOAT y2)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 }
add_vertex(FX_FLOAT x,FX_FLOAT y,unsigned cmd)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 }
move_to(int x,int y)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 }
line_to(int x,int y)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 }
close_polygon()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 }
calculate_alpha(int area,bool no_smooth)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 }
sort()298 AGG_INLINE void sort()
299 {
300 m_outline.sort_cells();
301 }
rewind_scanlines()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 }
navigate_scanline(int y)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 }
sweep_scanline(Scanline & sl,bool no_smooth)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&);
move_to_no_clip(int x,int y)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 }
line_to_no_clip(int x,int y)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 }
close_polygon_no_clip()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 }
clip_segment(int x,int y)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
473