| |
| //---------------------------------------------------------------------------- |
| // Anti-Grain Geometry - Version 2.3 |
| // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com) |
| // |
| // Permission to copy, use, modify, sell and distribute this software |
| // is granted provided this copyright notice appears in all copies. |
| // This software is provided "as is" without express or implied |
| // warranty, and with no claim as to its suitability for any purpose. |
| // |
| //---------------------------------------------------------------------------- |
| // |
| // The author gratefully acknowleges the support of David Turner, |
| // Robert Wilhelm, and Werner Lemberg - the authors of the FreeType |
| // libray - in producing this work. See http://www.freetype.org for details. |
| // |
| //---------------------------------------------------------------------------- |
| // Contact: mcseem@antigrain.com |
| // mcseemagg@yahoo.com |
| // http://www.antigrain.com |
| //---------------------------------------------------------------------------- |
| // |
| // Adaptation for 32-bit screen coordinates 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_RASTERIZER_SCANLINE_AA_INCLUDED |
| #define AGG_RASTERIZER_SCANLINE_AA_INCLUDED |
| |
| #include "agg_array.h" |
| #include "agg_basics.h" |
| #include "agg_clip_liang_barsky.h" |
| #include "agg_math.h" |
| #include "agg_render_scanlines.h" |
| #include "core/fxcrt/fx_coordinates.h" |
| #include "core/fxcrt/fx_memory.h" |
| |
| namespace pdfium |
| { |
| namespace agg |
| { |
| enum poly_base_scale_e { |
| poly_base_shift = 8, |
| poly_base_size = 1 << poly_base_shift, |
| poly_base_mask = poly_base_size - 1 |
| }; |
| inline int poly_coord(float c) |
| { |
| return int(c * poly_base_size); |
| } |
| struct cell_aa { |
| int x; |
| int y; |
| int cover; |
| int area; |
| void set(int x, int y, int c, int a); |
| void set_coord(int x, int y); |
| void set_cover(int c, int a); |
| void add_cover(int c, int a); |
| }; |
| class outline_aa |
| { |
| enum cell_block_scale_e { |
| cell_block_shift = 12, |
| cell_block_size = 1 << cell_block_shift, |
| cell_block_mask = cell_block_size - 1, |
| cell_block_pool = 256, |
| cell_block_limit = 1024 |
| }; |
| struct sorted_y { |
| unsigned start; |
| unsigned num; |
| }; |
| public: |
| ~outline_aa(); |
| outline_aa(); |
| void reset(); |
| void move_to(int x, int y); |
| void line_to(int x, int y); |
| int min_x() const |
| { |
| return m_min_x; |
| } |
| int min_y() const |
| { |
| return m_min_y; |
| } |
| int max_x() const |
| { |
| return m_max_x; |
| } |
| int max_y() const |
| { |
| return m_max_y; |
| } |
| void sort_cells(); |
| unsigned total_cells() const |
| { |
| return m_num_cells; |
| } |
| unsigned scanline_num_cells(unsigned y) const |
| { |
| return m_sorted_y[y - m_min_y].num; |
| } |
| const cell_aa* const* scanline_cells(unsigned y) const |
| { |
| return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start; |
| } |
| bool sorted() const |
| { |
| return m_sorted; |
| } |
| private: |
| outline_aa(const outline_aa&); |
| const outline_aa& operator = (const outline_aa&); |
| void set_cur_cell(int x, int y); |
| void add_cur_cell(); |
| void render_hline(int ey, int x1, int y1, int x2, int y2); |
| void render_line(int x1, int y1, int x2, int y2); |
| void allocate_block(); |
| private: |
| unsigned m_num_blocks; |
| unsigned m_max_blocks; |
| unsigned m_cur_block; |
| unsigned m_num_cells; |
| cell_aa** m_cells; |
| cell_aa* m_cur_cell_ptr; |
| pod_array<cell_aa*> m_sorted_cells; |
| pod_array<sorted_y> m_sorted_y; |
| cell_aa m_cur_cell; |
| int m_cur_x; |
| int m_cur_y; |
| int m_min_x; |
| int m_min_y; |
| int m_max_x; |
| int m_max_y; |
| bool m_sorted; |
| }; |
| class scanline_hit_test |
| { |
| public: |
| scanline_hit_test(int x) : m_x(x), m_hit(false) {} |
| void reset_spans() {} |
| void finalize(int) {} |
| void add_cell(int x, int) |
| { |
| if(m_x == x) { |
| m_hit = true; |
| } |
| } |
| void add_span(int x, int len, int) |
| { |
| if(m_x >= x && m_x < x + len) { |
| m_hit = true; |
| } |
| } |
| unsigned num_spans() const |
| { |
| return 1; |
| } |
| bool hit() const |
| { |
| return m_hit; |
| } |
| private: |
| int m_x; |
| bool m_hit; |
| }; |
| enum filling_rule_e { |
| fill_non_zero, |
| fill_even_odd |
| }; |
| class rasterizer_scanline_aa |
| { |
| enum status { |
| status_initial, |
| status_line_to, |
| status_closed |
| }; |
| public: |
| enum aa_scale_e { |
| aa_num = 1 << 8, |
| aa_mask = aa_num - 1, |
| aa_2num = aa_num * 2, |
| aa_2mask = aa_2num - 1 |
| }; |
| rasterizer_scanline_aa() : |
| m_filling_rule(fill_non_zero), |
| m_clipped_start_x(0), |
| m_clipped_start_y(0), |
| m_status(status_initial), |
| m_clipping(false) |
| { |
| } |
| ~rasterizer_scanline_aa() {} |
| void filling_rule(filling_rule_e filling_rule) |
| { |
| m_filling_rule = filling_rule; |
| } |
| int min_x() const |
| { |
| return m_outline.min_x(); |
| } |
| int min_y() const |
| { |
| return m_outline.min_y(); |
| } |
| int max_x() const |
| { |
| return m_outline.max_x(); |
| } |
| int max_y() const |
| { |
| return m_outline.max_y(); |
| } |
| void reset() |
| { |
| m_outline.reset(); |
| m_status = status_initial; |
| } |
| void clip_box(float x1, float y1, float x2, float y2) |
| { |
| m_clip_box = rect(poly_coord(x1), poly_coord(y1), |
| poly_coord(x2), poly_coord(y2)); |
| m_clip_box.normalize(); |
| m_clipping = true; |
| } |
| void add_vertex(float x, float y, unsigned cmd) |
| { |
| if(is_close(cmd)) { |
| close_polygon(); |
| } else { |
| if(is_move_to(cmd)) { |
| move_to(poly_coord(x), poly_coord(y)); |
| } else { |
| if(is_vertex(cmd)) { |
| line_to(poly_coord(x), poly_coord(y)); |
| } |
| } |
| } |
| } |
| void move_to(int x, int y) |
| { |
| if(m_clipping) { |
| if(m_outline.sorted()) { |
| reset(); |
| } |
| if(m_status == status_line_to) { |
| close_polygon(); |
| } |
| m_prev_x = m_start_x = x; |
| m_prev_y = m_start_y = y; |
| m_status = status_initial; |
| m_prev_flags = clipping_flags(x, y, m_clip_box); |
| if(m_prev_flags == 0) { |
| move_to_no_clip(x, y); |
| } |
| } else { |
| move_to_no_clip(x, y); |
| } |
| } |
| void line_to(int x, int y) |
| { |
| if(m_clipping) { |
| clip_segment(x, y); |
| } else { |
| line_to_no_clip(x, y); |
| } |
| } |
| void close_polygon() |
| { |
| if (m_status != status_line_to) { |
| return; |
| } |
| if(m_clipping) { |
| clip_segment(m_start_x, m_start_y); |
| } |
| close_polygon_no_clip(); |
| } |
| AGG_INLINE unsigned calculate_alpha(int area, bool no_smooth) const |
| { |
| int cover = area >> (poly_base_shift * 2 + 1 - 8); |
| if(cover < 0) { |
| cover = -cover; |
| } |
| if(m_filling_rule == fill_even_odd) { |
| cover &= aa_2mask; |
| if(cover > aa_num) { |
| cover = aa_2num - cover; |
| } |
| } |
| if (no_smooth) { |
| cover = cover > aa_mask / 2 ? aa_mask : 0; |
| } |
| if(cover > aa_mask) { |
| cover = aa_mask; |
| } |
| return cover; |
| } |
| AGG_INLINE void sort() |
| { |
| m_outline.sort_cells(); |
| } |
| AGG_INLINE bool rewind_scanlines() |
| { |
| close_polygon(); |
| m_outline.sort_cells(); |
| if(m_outline.total_cells() == 0) { |
| return false; |
| } |
| m_cur_y = m_outline.min_y(); |
| return true; |
| } |
| AGG_INLINE bool navigate_scanline(int y) |
| { |
| close_polygon(); |
| m_outline.sort_cells(); |
| if(m_outline.total_cells() == 0 || |
| y < m_outline.min_y() || |
| y > m_outline.max_y()) { |
| return false; |
| } |
| m_cur_y = y; |
| return true; |
| } |
| template<class Scanline> bool sweep_scanline(Scanline& sl, bool no_smooth) |
| { |
| for(;;) { |
| if(m_cur_y > m_outline.max_y()) { |
| return false; |
| } |
| sl.reset_spans(); |
| unsigned num_cells = m_outline.scanline_num_cells(m_cur_y); |
| const cell_aa* const* cells = m_outline.scanline_cells(m_cur_y); |
| int cover = 0; |
| while(num_cells) { |
| const cell_aa* cur_cell = *cells; |
| int x = cur_cell->x; |
| int area = cur_cell->area; |
| bool seen_area_overflow = false; |
| bool seen_cover_overflow = false; |
| if(!safe_add(&cover, cur_cell->cover)) { |
| break; |
| } |
| while(--num_cells) { |
| cur_cell = *++cells; |
| if(cur_cell->x != x) { |
| break; |
| } |
| if(seen_area_overflow) { |
| continue; |
| } |
| if(!safe_add(&area, cur_cell->area)) { |
| seen_area_overflow = true; |
| continue; |
| } |
| if(!safe_add(&cover, cur_cell->cover)) { |
| seen_cover_overflow = true; |
| break; |
| } |
| } |
| if(seen_area_overflow) { |
| continue; |
| } |
| if(seen_cover_overflow) { |
| break; |
| } |
| if(area) { |
| unsigned alpha = calculate_alpha(calculate_area(cover, poly_base_shift + 1) - area, no_smooth); |
| if(alpha) { |
| sl.add_cell(x, alpha); |
| } |
| x++; |
| } |
| if(num_cells && cur_cell->x > x) { |
| unsigned alpha = calculate_alpha(calculate_area(cover, poly_base_shift + 1), no_smooth); |
| if(alpha) { |
| sl.add_span(x, cur_cell->x - x, alpha); |
| } |
| } |
| } |
| if(sl.num_spans()) { |
| break; |
| } |
| ++m_cur_y; |
| } |
| sl.finalize(m_cur_y); |
| ++m_cur_y; |
| return true; |
| } |
| template<class VertexSource> |
| void add_path(VertexSource& vs, unsigned path_id = 0) |
| { |
| float x; |
| float y; |
| unsigned cmd; |
| vs.rewind(path_id); |
| while(!is_stop(cmd = vs.vertex(&x, &y))) { |
| add_vertex(x, y, cmd); |
| } |
| } |
| template<class VertexSource> |
| void add_path_transformed(VertexSource& vs, const CFX_Matrix* pMatrix, unsigned path_id = 0) |
| { |
| float x; |
| float y; |
| unsigned cmd; |
| vs.rewind(path_id); |
| while(!is_stop(cmd = vs.vertex(&x, &y))) { |
| if (pMatrix) { |
| CFX_PointF ret = pMatrix->Transform(CFX_PointF(x, y)); |
| x = ret.x; |
| y = ret.y; |
| } |
| add_vertex(x, y, cmd); |
| } |
| } |
| private: |
| rasterizer_scanline_aa(const rasterizer_scanline_aa&); |
| const rasterizer_scanline_aa& |
| operator = (const rasterizer_scanline_aa&); |
| void move_to_no_clip(int x, int y) |
| { |
| if(m_status == status_line_to) { |
| close_polygon_no_clip(); |
| } |
| m_outline.move_to(x * 1, y); |
| m_clipped_start_x = x; |
| m_clipped_start_y = y; |
| m_status = status_line_to; |
| } |
| void line_to_no_clip(int x, int y) |
| { |
| if(m_status != status_initial) { |
| m_outline.line_to(x * 1, y); |
| m_status = status_line_to; |
| } |
| } |
| void close_polygon_no_clip() |
| { |
| if(m_status == status_line_to) { |
| m_outline.line_to(m_clipped_start_x * 1, m_clipped_start_y); |
| m_status = status_closed; |
| } |
| } |
| void clip_segment(int x, int y) |
| { |
| unsigned flags = clipping_flags(x, y, m_clip_box); |
| if(m_prev_flags == flags) { |
| if(flags == 0) { |
| if(m_status == status_initial) { |
| move_to_no_clip(x, y); |
| } else { |
| line_to_no_clip(x, y); |
| } |
| } |
| } else { |
| int cx[4]; |
| int cy[4]; |
| unsigned n = clip_liang_barsky(m_prev_x, m_prev_y, |
| x, y, |
| m_clip_box, |
| cx, cy); |
| const int* px = cx; |
| const int* py = cy; |
| while(n--) { |
| if(m_status == status_initial) { |
| move_to_no_clip(*px++, *py++); |
| } else { |
| line_to_no_clip(*px++, *py++); |
| } |
| } |
| } |
| m_prev_flags = flags; |
| m_prev_x = x; |
| m_prev_y = y; |
| } |
| private: |
| static int calculate_area(int cover, int shift); |
| static bool safe_add(int* op1, int op2); |
| |
| outline_aa m_outline; |
| filling_rule_e m_filling_rule; |
| int m_clipped_start_x; |
| int m_clipped_start_y; |
| int m_start_x; |
| int m_start_y; |
| int m_prev_x; |
| int m_prev_y; |
| unsigned m_prev_flags; |
| unsigned m_status; |
| rect m_clip_box; |
| bool m_clipping; |
| int m_cur_y; |
| }; |
| } |
| } // namespace pdfium |
| #endif |
