From 2ca8fcbc8a7a3ef6adfac154c47068c1696205d0 Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Tue, 16 Jun 2015 16:29:44 -0700 Subject: Separate agg-authored code from fx-authored code. Creates a separate library so we can apply less-strict warnings to the code we can't change from upstream vs. the code we can change, reducing noise in the standalone build. Remove needless foo.{cpp,h} files that merely perform indirection via #include "some_other_path/foo.{cpp,h}". BUG=pdfium:166 R=brucedawson@chromium.org, thestig@chromium.org Review URL: https://codereview.chromium.org/1152743007. --- third_party/agg23/agg_array.h | 506 +++++++++++++++++++++++ third_party/agg23/agg_basics.h | 282 +++++++++++++ third_party/agg23/agg_clip_liang_barsky.h | 125 ++++++ third_party/agg23/agg_color_gray.h | 50 +++ third_party/agg23/agg_conv_adaptor_vcgen.h | 138 +++++++ third_party/agg23/agg_conv_dash.h | 61 +++ third_party/agg23/agg_conv_stroke.h | 110 +++++ third_party/agg23/agg_curves.cpp | 109 +++++ third_party/agg23/agg_curves.h | 188 +++++++++ third_party/agg23/agg_math.h | 63 +++ third_party/agg23/agg_math_stroke.h | 272 ++++++++++++ third_party/agg23/agg_path_storage.cpp | 98 +++++ third_party/agg23/agg_path_storage.h | 172 ++++++++ third_party/agg23/agg_pixfmt_gray.h | 177 ++++++++ third_party/agg23/agg_rasterizer_scanline_aa.cpp | 489 ++++++++++++++++++++++ third_party/agg23/agg_rasterizer_scanline_aa.h | 472 +++++++++++++++++++++ third_party/agg23/agg_render_scanlines.h | 50 +++ third_party/agg23/agg_renderer_base.h | 163 ++++++++ third_party/agg23/agg_renderer_scanline.h | 93 +++++ third_party/agg23/agg_rendering_buffer.h | 145 +++++++ third_party/agg23/agg_scanline_u.h | 150 +++++++ third_party/agg23/agg_shorten_path.h | 57 +++ third_party/agg23/agg_vcgen_dash.cpp | 176 ++++++++ third_party/agg23/agg_vcgen_dash.h | 75 ++++ third_party/agg23/agg_vcgen_stroke.cpp | 214 ++++++++++ third_party/agg23/agg_vcgen_stroke.h | 120 ++++++ third_party/agg23/agg_vertex_sequence.h | 100 +++++ 27 files changed, 4655 insertions(+) create mode 100644 third_party/agg23/agg_array.h create mode 100644 third_party/agg23/agg_basics.h create mode 100644 third_party/agg23/agg_clip_liang_barsky.h create mode 100644 third_party/agg23/agg_color_gray.h create mode 100644 third_party/agg23/agg_conv_adaptor_vcgen.h create mode 100644 third_party/agg23/agg_conv_dash.h create mode 100644 third_party/agg23/agg_conv_stroke.h create mode 100644 third_party/agg23/agg_curves.cpp create mode 100644 third_party/agg23/agg_curves.h create mode 100644 third_party/agg23/agg_math.h create mode 100644 third_party/agg23/agg_math_stroke.h create mode 100644 third_party/agg23/agg_path_storage.cpp create mode 100644 third_party/agg23/agg_path_storage.h create mode 100644 third_party/agg23/agg_pixfmt_gray.h create mode 100644 third_party/agg23/agg_rasterizer_scanline_aa.cpp create mode 100644 third_party/agg23/agg_rasterizer_scanline_aa.h create mode 100644 third_party/agg23/agg_render_scanlines.h create mode 100644 third_party/agg23/agg_renderer_base.h create mode 100644 third_party/agg23/agg_renderer_scanline.h create mode 100644 third_party/agg23/agg_rendering_buffer.h create mode 100644 third_party/agg23/agg_scanline_u.h create mode 100644 third_party/agg23/agg_shorten_path.h create mode 100644 third_party/agg23/agg_vcgen_dash.cpp create mode 100644 third_party/agg23/agg_vcgen_dash.h create mode 100644 third_party/agg23/agg_vcgen_stroke.cpp create mode 100644 third_party/agg23/agg_vcgen_stroke.h create mode 100644 third_party/agg23/agg_vertex_sequence.h (limited to 'third_party/agg23') diff --git a/third_party/agg23/agg_array.h b/third_party/agg23/agg_array.h new file mode 100644 index 0000000000..810eb4ef22 --- /dev/null +++ b/third_party/agg23/agg_array.h @@ -0,0 +1,506 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_ARRAY_INCLUDED +#define AGG_ARRAY_INCLUDED +#include "agg_basics.h" +namespace agg +{ +template class pod_array +{ +public: + typedef T value_type; + ~pod_array() + { + FX_Free(m_array); + } + pod_array() : m_size(0), m_capacity(0), m_array(0) {} + pod_array(unsigned cap, unsigned extra_tail = 0); + pod_array(const pod_array&); + const pod_array& operator = (const pod_array&); + void capacity(unsigned cap, unsigned extra_tail = 0); + unsigned capacity() const + { + return m_capacity; + } + void allocate(unsigned size, unsigned extra_tail = 0); + void resize(unsigned new_size); + void zero() + { + FXSYS_memset(m_array, 0, sizeof(T) * m_size); + } + void add(const T& v) + { + m_array[m_size++] = v; + } + void inc_size(unsigned size) + { + m_size += size; + } + unsigned size() const + { + return m_size; + } + unsigned byte_size() const + { + return m_size * sizeof(T); + } + const T& operator [] (unsigned i) const + { + return m_array[i]; + } + T& operator [] (unsigned i) + { + return m_array[i]; + } + const T& at(unsigned i) const + { + return m_array[i]; + } + T& at(unsigned i) + { + return m_array[i]; + } + T value_at(unsigned i) const + { + return m_array[i]; + } + const T* data() const + { + return m_array; + } + T* data() + { + return m_array; + } + void remove_all() + { + m_size = 0; + } + void cut_at(unsigned num) + { + if(num < m_size) { + m_size = num; + } + } +private: + unsigned m_size; + unsigned m_capacity; + T* m_array; +}; +template +void pod_array::capacity(unsigned cap, unsigned extra_tail) +{ + m_size = 0; + unsigned full_cap = cap + extra_tail; + if(full_cap < cap) { + FX_Free(m_array); + m_array = 0; + m_capacity = 0; + } else if(full_cap > m_capacity) { + FX_Free(m_array); + m_array = FX_Alloc(T, full_cap); + m_capacity = full_cap; + } +} +template +void pod_array::allocate(unsigned size, unsigned extra_tail) +{ + capacity(size, extra_tail); + m_size = size; +} +template +void pod_array::resize(unsigned new_size) +{ + if(new_size > m_size) { + if(new_size > m_capacity) { + T* data = FX_Alloc(T, new_size); + FXSYS_memcpy(data, m_array, m_size * sizeof(T)); + FX_Free(m_array); + m_array = data; + } + } else { + m_size = new_size; + } +} +template pod_array::pod_array(unsigned cap, unsigned extra_tail) : + m_size(0), m_capacity(cap + extra_tail), m_array(FX_Alloc(T, m_capacity)) {} +template pod_array::pod_array(const pod_array& v) : + m_size(v.m_size), + m_capacity(v.m_capacity), + m_array(v.m_capacity ? FX_Alloc(T, v.m_capacity) : 0) +{ + FXSYS_memcpy(m_array, v.m_array, sizeof(T) * v.m_size); +} +template const pod_array& +pod_array::operator = (const pod_array&v) +{ + allocate(v.m_size); + if(v.m_size) { + FXSYS_memcpy(m_array, v.m_array, sizeof(T) * v.m_size); + } + return *this; +} +template class pod_deque +{ +public: + enum block_scale_e { + block_shift = S, + block_size = 1 << block_shift, + block_mask = block_size - 1 + }; + typedef T value_type; + ~pod_deque(); + pod_deque(); + pod_deque(unsigned block_ptr_inc); + pod_deque(const pod_deque& v); + const pod_deque& operator = (const pod_deque& v); + void remove_all() + { + m_size = 0; + } + void free_all() + { + free_tail(0); + } + void free_tail(unsigned size); + void add(const T& val); + void modify_last(const T& val); + void remove_last(); + int allocate_continuous_block(unsigned num_elements); + void add_array(const T* ptr, unsigned num_elem) + { + while(num_elem--) { + add(*ptr++); + } + } + template void add_data(DataAccessor& data) + { + while(data.size()) { + add(*data); + ++data; + } + } + void cut_at(unsigned size) + { + if(size < m_size) { + m_size = size; + } + } + unsigned size() const + { + return m_size; + } + const T& operator [] (unsigned i) const + { + return m_blocks[i >> block_shift][i & block_mask]; + } + T& operator [] (unsigned i) + { + return m_blocks[i >> block_shift][i & block_mask]; + } + const T& at(unsigned i) const + { + return m_blocks[i >> block_shift][i & block_mask]; + } + T& at(unsigned i) + { + return m_blocks[i >> block_shift][i & block_mask]; + } + T value_at(unsigned i) const + { + return m_blocks[i >> block_shift][i & block_mask]; + } + const T& curr(unsigned idx) const + { + return (*this)[idx]; + } + T& curr(unsigned idx) + { + return (*this)[idx]; + } + const T& prev(unsigned idx) const + { + return (*this)[(idx + m_size - 1) % m_size]; + } + T& prev(unsigned idx) + { + return (*this)[(idx + m_size - 1) % m_size]; + } + const T& next(unsigned idx) const + { + return (*this)[(idx + 1) % m_size]; + } + T& next(unsigned idx) + { + return (*this)[(idx + 1) % m_size]; + } + const T& last() const + { + return (*this)[m_size - 1]; + } + T& last() + { + return (*this)[m_size - 1]; + } + unsigned byte_size() const; + const T* block(unsigned nb) const + { + return m_blocks[nb]; + } +public: + void allocate_block(unsigned nb); + T* data_ptr(); + unsigned m_size; + unsigned m_num_blocks; + unsigned m_max_blocks; + T** m_blocks; + unsigned m_block_ptr_inc; +}; +template pod_deque::~pod_deque() +{ + if(m_num_blocks) { + T** blk = m_blocks + m_num_blocks - 1; + while(m_num_blocks--) { + FX_Free(*blk); + --blk; + } + FX_Free(m_blocks); + } +} +template +void pod_deque::free_tail(unsigned size) +{ + if(size < m_size) { + unsigned nb = (size + block_mask) >> block_shift; + while(m_num_blocks > nb) { + FX_Free(m_blocks[--m_num_blocks]); + } + m_size = size; + } +} +template pod_deque::pod_deque() : + m_size(0), + m_num_blocks(0), + m_max_blocks(0), + m_blocks(0), + m_block_ptr_inc(block_size) +{ +} +template +pod_deque::pod_deque(unsigned block_ptr_inc) : + m_size(0), + m_num_blocks(0), + m_max_blocks(0), + m_blocks(0), + m_block_ptr_inc(block_ptr_inc) +{ +} +template +pod_deque::pod_deque(const pod_deque& v) : + m_size(v.m_size), + m_num_blocks(v.m_num_blocks), + m_max_blocks(v.m_max_blocks), + m_blocks(v.m_max_blocks ? FX_Alloc(T*, v.m_max_blocks) : 0), + m_block_ptr_inc(v.m_block_ptr_inc) +{ + unsigned i; + for(i = 0; i < v.m_num_blocks; ++i) { + m_blocks[i] = FX_Alloc(T, block_size); + FXSYS_memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T)); + } +} +template +const pod_deque& pod_deque::operator = (const pod_deque& v) +{ + unsigned i; + for(i = m_num_blocks; i < v.m_num_blocks; ++i) { + allocate_block(i); + } + for(i = 0; i < v.m_num_blocks; ++i) { + FXSYS_memcpy(m_blocks[i], v.m_blocks[i], block_size * sizeof(T)); + } + m_size = v.m_size; + return *this; +} +template +void pod_deque::allocate_block(unsigned nb) +{ + if(nb >= m_max_blocks) { + T** new_blocks = FX_Alloc(T*, m_max_blocks + m_block_ptr_inc); + if(m_blocks) { + FXSYS_memcpy(new_blocks, + m_blocks, + m_num_blocks * sizeof(T*)); + FX_Free(m_blocks); + } + m_blocks = new_blocks; + m_max_blocks += m_block_ptr_inc; + } + m_blocks[nb] = FX_Alloc(T, block_size); + m_num_blocks++; +} +template +inline T* pod_deque::data_ptr() +{ + unsigned nb = m_size >> block_shift; + if(nb >= m_num_blocks) { + allocate_block(nb); + } + return m_blocks[nb] + (m_size & block_mask); +} +template +inline void pod_deque::add(const T& val) +{ + *data_ptr() = val; + ++m_size; +} +template +inline void pod_deque::remove_last() +{ + if(m_size) { + --m_size; + } +} +template +void pod_deque::modify_last(const T& val) +{ + remove_last(); + add(val); +} +template +int pod_deque::allocate_continuous_block(unsigned num_elements) +{ + if(num_elements < block_size) { + data_ptr(); + unsigned rest = block_size - (m_size & block_mask); + unsigned index; + if(num_elements <= rest) { + index = m_size; + m_size += num_elements; + return index; + } + m_size += rest; + data_ptr(); + index = m_size; + m_size += num_elements; + return index; + } + return -1; +} +template +unsigned pod_deque::byte_size() const +{ + return m_size * sizeof(T); +} +class pod_allocator +{ +public: + void remove_all() + { + if(m_num_blocks) { + int8u** blk = m_blocks + m_num_blocks - 1; + while(m_num_blocks--) { + FX_Free(*blk); + --blk; + } + FX_Free(m_blocks); + } + m_num_blocks = 0; + m_max_blocks = 0; + m_blocks = 0; + m_buf_ptr = 0; + m_rest = 0; + } + ~pod_allocator() + { + remove_all(); + } + pod_allocator(unsigned block_size, unsigned block_ptr_inc = 256 - 8) : + m_block_size(block_size), + m_block_ptr_inc(block_ptr_inc), + m_num_blocks(0), + m_max_blocks(0), + m_blocks(0), + m_buf_ptr(0), + m_rest(0) + { + } + int8u* allocate(unsigned size, unsigned alignment = 1) + { + if(size == 0) { + return 0; + } + if(size <= m_rest) { + int8u* ptr = m_buf_ptr; + if(alignment > 1) { + unsigned align = (alignment - unsigned((size_t)ptr) % alignment) % alignment; + size += align; + ptr += align; + if(size <= m_rest) { + m_rest -= size; + m_buf_ptr += size; + return ptr; + } + allocate_block(size); + return allocate(size - align, alignment); + } + m_rest -= size; + m_buf_ptr += size; + return ptr; + } + allocate_block(size + alignment - 1); + return allocate(size, alignment); + } +private: + void allocate_block(unsigned size) + { + if(size < m_block_size) { + size = m_block_size; + } + if(m_num_blocks >= m_max_blocks) { + int8u** new_blocks = FX_Alloc(int8u*, m_max_blocks + m_block_ptr_inc); + if(m_blocks) { + FXSYS_memcpy(new_blocks, + m_blocks, + m_num_blocks * sizeof(int8u*)); + FX_Free(m_blocks); + } + m_blocks = new_blocks; + m_max_blocks += m_block_ptr_inc; + } + m_blocks[m_num_blocks] = m_buf_ptr = FX_Alloc(int8u, size); + m_num_blocks++; + m_rest = size; + } + unsigned m_block_size; + unsigned m_block_ptr_inc; + unsigned m_num_blocks; + unsigned m_max_blocks; + int8u** m_blocks; + int8u* m_buf_ptr; + unsigned m_rest; +}; +enum quick_sort_threshold_e { + quick_sort_threshold = 9 +}; +template inline void swap_elements(T& a, T& b) +{ + T temp = a; + a = b; + b = temp; +} +} +#endif diff --git a/third_party/agg23/agg_basics.h b/third_party/agg23/agg_basics.h new file mode 100644 index 0000000000..d2fad58feb --- /dev/null +++ b/third_party/agg23/agg_basics.h @@ -0,0 +1,282 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_BASICS_INCLUDED +#define AGG_BASICS_INCLUDED +#ifndef AGG_INT8 +#define AGG_INT8 signed char +#endif +#ifndef AGG_INT8U +#define AGG_INT8U unsigned char +#endif +#ifndef AGG_INT16 +#define AGG_INT16 short +#endif +#ifndef AGG_INT16U +#define AGG_INT16U unsigned short +#endif +#ifndef AGG_INT32 +#define AGG_INT32 int +#endif +#ifndef AGG_INT32U +#define AGG_INT32U unsigned +#endif +#ifndef AGG_INT64 +#define AGG_INT64 signed long long +#endif +#ifndef AGG_INT64U +#define AGG_INT64U unsigned long long +#endif +#define AGG_INLINE inline +namespace agg +{ +typedef AGG_INT8 int8; +typedef AGG_INT8U int8u; +typedef AGG_INT16 int16; +typedef AGG_INT16U int16u; +typedef AGG_INT32 int32; +typedef AGG_INT32U int32u; +typedef AGG_INT64 int64; +typedef AGG_INT64U int64u; +typedef unsigned char cover_type; +enum cover_scale_e { + cover_shift = 8, + cover_size = 1 << cover_shift, + cover_mask = cover_size - 1, + cover_none = 0, + cover_full = cover_mask +}; +template struct rect_base { + typedef rect_base self_type; + T x1; + T y1; + T x2; + T y2; + rect_base() {} + rect_base(T x1_, T y1_, T x2_, T y2_) : + x1(x1_), y1(y1_), x2(x2_), y2(y2_) {} + const self_type& normalize() + { + T t; + if(x1 > x2) { + t = x1; + x1 = x2; + x2 = t; + } + if(y1 > y2) { + t = y1; + y1 = y2; + y2 = t; + } + return *this; + } + bool clip(const self_type& r) + { + if(x2 > r.x2) { + x2 = r.x2; + } + if(y2 > r.y2) { + y2 = r.y2; + } + if(x1 < r.x1) { + x1 = r.x1; + } + if(y1 < r.y1) { + y1 = r.y1; + } + return x1 <= x2 && y1 <= y2; + } + bool is_valid() const + { + return x1 <= x2 && y1 <= y2; + } +}; +template +inline Rect intersect_rectangles(const Rect& r1, const Rect& r2) +{ + Rect r = r1; + if(r.x2 > r2.x2) { + r.x2 = r2.x2; + } + if(r.y2 > r2.y2) { + r.y2 = r2.y2; + } + if(r.x1 < r2.x1) { + r.x1 = r2.x1; + } + if(r.y1 < r2.y1) { + r.y1 = r2.y1; + } + return r; +} +template +inline Rect unite_rectangles(const Rect& r1, const Rect& r2) +{ + Rect r = r1; + if(r.x2 < r2.x2) { + r.x2 = r2.x2; + } + if(r.y2 < r2.y2) { + r.y2 = r2.y2; + } + if(r.x1 > r2.x1) { + r.x1 = r2.x1; + } + if(r.y1 > r2.y1) { + r.y1 = r2.y1; + } + return r; +} +typedef rect_base rect; +typedef rect_base rect_d; +enum path_commands_e { + path_cmd_stop = 0, + path_cmd_move_to = 1, + path_cmd_line_to = 2, + path_cmd_curve3 = 3, + path_cmd_curve4 = 4, + path_cmd_curveN = 5, + path_cmd_catrom = 6, + path_cmd_ubspline = 7, + path_cmd_end_poly = 0x0F, + path_cmd_mask = 0x0F +}; +enum path_flags_e { + path_flags_none = 0, + path_flags_ccw = 0x10, + path_flags_cw = 0x20, + path_flags_close = 0x40, + path_flags_jr = 0x80, + path_flags_mask = 0xF0 +}; +inline bool is_vertex(unsigned c) +{ + c &= ~path_flags_jr; + return c >= path_cmd_move_to && c < path_cmd_end_poly; +} +inline bool is_drawing(unsigned c) +{ + c &= ~path_flags_jr; + return c >= path_cmd_line_to && c < path_cmd_end_poly; +} +inline bool is_stop(unsigned c) +{ + c &= ~path_flags_jr; + return c == path_cmd_stop; +} +inline bool is_move_to(unsigned c) +{ + c &= ~path_flags_jr; + return c == path_cmd_move_to; +} +inline bool is_line_to(unsigned c) +{ + c &= ~path_flags_jr; + return c == path_cmd_line_to; +} +inline bool is_curve(unsigned c) +{ + c &= ~path_flags_jr; + return c == path_cmd_curve3 || c == path_cmd_curve4; +} +inline bool is_curve3(unsigned c) +{ + c &= ~path_flags_jr; + return c == path_cmd_curve3; +} +inline bool is_curve4(unsigned c) +{ + c &= ~path_flags_jr; + return c == path_cmd_curve4; +} +inline bool is_end_poly(unsigned c) +{ + c &= ~path_flags_jr; + return (c & path_cmd_mask) == path_cmd_end_poly; +} +inline bool is_close(unsigned c) +{ + c &= ~path_flags_jr; + return (c & ~(path_flags_cw | path_flags_ccw)) == + (path_cmd_end_poly | path_flags_close); +} +inline bool is_next_poly(unsigned c) +{ + c &= ~path_flags_jr; + return is_stop(c) || is_move_to(c) || is_end_poly(c); +} +inline bool is_cw(unsigned c) +{ + c &= ~path_flags_jr; + return (c & path_flags_cw) != 0; +} +inline bool is_ccw(unsigned c) +{ + c &= ~path_flags_jr; + return (c & path_flags_ccw) != 0; +} +inline bool is_oriented(unsigned c) +{ + c &= ~path_flags_jr; + return (c & (path_flags_cw | path_flags_ccw)) != 0; +} +inline bool is_closed(unsigned c) +{ + c &= ~path_flags_jr; + return (c & path_flags_close) != 0; +} +inline unsigned get_close_flag(unsigned c) +{ + c &= ~path_flags_jr; + return c & path_flags_close; +} +inline unsigned clear_orientation(unsigned c) +{ + c &= ~path_flags_jr; + return c & ~(path_flags_cw | path_flags_ccw); +} +inline unsigned get_orientation(unsigned c) +{ + c &= ~path_flags_jr; + return c & (path_flags_cw | path_flags_ccw); +} +inline unsigned set_orientation(unsigned c, unsigned o) +{ + c &= ~path_flags_jr; + return clear_orientation(c) | o; +} +struct point_type { + FX_FLOAT x, y; + unsigned flag; + point_type() {} + point_type(FX_FLOAT x_, FX_FLOAT y_, unsigned flag_ = 0) : x(x_), y(y_), flag(flag_) {} +}; +struct point_type_flag : public point_type { + unsigned flag; + point_type_flag() + { + flag = 0; + } + point_type_flag(FX_FLOAT x_, FX_FLOAT y_, unsigned flag_ = 0) : point_type(x_, y_), flag(flag_) {} +}; +struct vertex_type { + FX_FLOAT x, y; + unsigned cmd; + vertex_type() {} + vertex_type(FX_FLOAT x_, FX_FLOAT y_, unsigned cmd_) : + x(x_), y(y_), cmd(cmd_) {} +}; +} +#endif diff --git a/third_party/agg23/agg_clip_liang_barsky.h b/third_party/agg23/agg_clip_liang_barsky.h new file mode 100644 index 0000000000..cfc4c91f60 --- /dev/null +++ b/third_party/agg23/agg_clip_liang_barsky.h @@ -0,0 +1,125 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Liang-Barsky clipping +// +//---------------------------------------------------------------------------- +#ifndef AGG_CLIP_LIANG_BARSKY_INCLUDED +#define AGG_CLIP_LIANG_BARSKY_INCLUDED +#include "agg_basics.h" +namespace agg +{ +template +inline unsigned clipping_flags(T x, T y, const rect_base& clip_box) +{ + return (x > clip_box.x2) | + ((y > clip_box.y2) << 1) | + ((x < clip_box.x1) << 2) | + ((y < clip_box.y1) << 3); +} +template +inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2, + const rect_base& clip_box, + T* x, T* y) +{ + const FX_FLOAT nearzero = 1e-30f; + FX_FLOAT deltax = (FX_FLOAT)(x2 - x1); + FX_FLOAT deltay = (FX_FLOAT)(y2 - y1); + unsigned np = 0; + if(deltax == 0) { + deltax = (x1 > clip_box.x1) ? -nearzero : nearzero; + } + FX_FLOAT xin, xout; + if(deltax > 0) { + xin = (FX_FLOAT)clip_box.x1; + xout = (FX_FLOAT)clip_box.x2; + } else { + xin = (FX_FLOAT)clip_box.x2; + xout = (FX_FLOAT)clip_box.x1; + } + FX_FLOAT tinx = FXSYS_Div(xin - x1, deltax); + if(deltay == 0) { + deltay = (y1 > clip_box.y1) ? -nearzero : nearzero; + } + FX_FLOAT yin, yout; + if(deltay > 0) { + yin = (FX_FLOAT)clip_box.y1; + yout = (FX_FLOAT)clip_box.y2; + } else { + yin = (FX_FLOAT)clip_box.y2; + yout = (FX_FLOAT)clip_box.y1; + } + FX_FLOAT tiny = FXSYS_Div(yin - y1, deltay); + FX_FLOAT tin1, tin2; + if (tinx < tiny) { + tin1 = tinx; + tin2 = tiny; + } else { + tin1 = tiny; + tin2 = tinx; + } + if(tin1 <= 1.0f) { + if(0 < tin1) { + *x++ = (T)xin; + *y++ = (T)yin; + ++np; + } + if(tin2 <= 1.0f) { + FX_FLOAT toutx = FXSYS_Div(xout - x1, deltax); + FX_FLOAT touty = FXSYS_Div(yout - y1, deltay); + FX_FLOAT tout1 = (toutx < touty) ? toutx : touty; + if(tin2 > 0 || tout1 > 0) { + if(tin2 <= tout1) { + if(tin2 > 0) { + if(tinx > tiny) { + *x++ = (T)xin; + *y++ = (T)(y1 + FXSYS_Mul(deltay, tinx)); + } else { + *x++ = (T)(x1 + FXSYS_Mul(deltax, tiny)); + *y++ = (T)yin; + } + ++np; + } + if(tout1 < 1.0f) { + if(toutx < touty) { + *x++ = (T)xout; + *y++ = (T)(y1 + FXSYS_Mul(deltay, toutx)); + } else { + *x++ = (T)(x1 + FXSYS_Mul(deltax, touty)); + *y++ = (T)yout; + } + } else { + *x++ = x2; + *y++ = y2; + } + ++np; + } else { + if(tinx > tiny) { + *x++ = (T)xin; + *y++ = (T)yout; + } else { + *x++ = (T)xout; + *y++ = (T)yin; + } + ++np; + } + } + } + } + return np; +} +} +#endif diff --git a/third_party/agg23/agg_color_gray.h b/third_party/agg23/agg_color_gray.h new file mode 100644 index 0000000000..5db7bcaf28 --- /dev/null +++ b/third_party/agg23/agg_color_gray.h @@ -0,0 +1,50 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Adaptation for high precision colors 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. +// +//---------------------------------------------------------------------------- +// +// color types gray8, gray16 +// +//---------------------------------------------------------------------------- +#ifndef AGG_COLOR_GRAY_INCLUDED +#define AGG_COLOR_GRAY_INCLUDED +#include "agg_basics.h" +namespace agg +{ +struct gray8 { + typedef int8u value_type; + typedef int32u calc_type; + typedef int32 long_type; + enum base_scale_e { + base_shift = 8, + base_size = 1 << base_shift, + base_mask = base_size - 1 + }; + typedef gray8 self_type; + value_type v; + value_type a; + gray8() {} + gray8(unsigned v_, unsigned a_ = base_mask) : + v(int8u(v_)), a(int8u(a_)) {} +}; +} +#endif diff --git a/third_party/agg23/agg_conv_adaptor_vcgen.h b/third_party/agg23/agg_conv_adaptor_vcgen.h new file mode 100644 index 0000000000..0d8d6ff99e --- /dev/null +++ b/third_party/agg23/agg_conv_adaptor_vcgen.h @@ -0,0 +1,138 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_CONV_ADAPTOR_VCGEN_INCLUDED +#define AGG_CONV_ADAPTOR_VCGEN_INCLUDED +#include "agg_basics.h" +namespace agg +{ +struct null_markers { + void remove_all() {} + void add_vertex(FX_FLOAT, FX_FLOAT, unsigned) {} + void prepare_src() {} + void rewind(unsigned) {} + unsigned vertex(FX_FLOAT*, FX_FLOAT*) + { + return path_cmd_stop; + } +}; +template class conv_adaptor_vcgen +{ + enum status { + initial, + accumulate, + generate + }; +public: + conv_adaptor_vcgen(VertexSource& source) : + m_source(&source), + m_status(initial) + {} + void set_source(VertexSource& source) + { + m_source = &source; + } + Generator& generator() + { + return m_generator; + } + const Generator& generator() const + { + return m_generator; + } + Markers& markers() + { + return m_markers; + } + const Markers& markers() const + { + return m_markers; + } + void rewind(unsigned path_id) + { + m_source->rewind(path_id); + m_status = initial; + } + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); +private: + conv_adaptor_vcgen(const conv_adaptor_vcgen&); + const conv_adaptor_vcgen& + operator = (const conv_adaptor_vcgen&); + VertexSource* m_source; + Generator m_generator; + Markers m_markers; + status m_status; + unsigned m_last_cmd; + FX_FLOAT m_start_x; + FX_FLOAT m_start_y; +}; +template +unsigned conv_adaptor_vcgen::vertex(FX_FLOAT* x, FX_FLOAT* y) +{ + unsigned cmd = path_cmd_stop; + bool done = false; + while(!done) { + switch(m_status) { + case initial: + m_markers.remove_all(); + m_last_cmd = m_source->vertex(&m_start_x, &m_start_y); + m_status = accumulate; + case accumulate: + if(is_stop(m_last_cmd)) { + return path_cmd_stop; + } + m_generator.remove_all(); + m_generator.add_vertex(m_start_x, m_start_y, path_cmd_move_to); + m_markers.add_vertex(m_start_x, m_start_y, path_cmd_move_to); + for(;;) { + cmd = m_source->vertex(x, y); + if(is_vertex(cmd)) { + m_last_cmd = cmd; + if(is_move_to(cmd)) { + m_start_x = *x; + m_start_y = *y; + break; + } + m_generator.add_vertex(*x, *y, cmd); + m_markers.add_vertex(*x, *y, path_cmd_line_to); + } else { + if(is_stop(cmd)) { + m_last_cmd = path_cmd_stop; + break; + } + if(is_end_poly(cmd)) { + m_generator.add_vertex(*x, *y, cmd); + break; + } + } + } + m_generator.rewind(0); + m_status = generate; + case generate: + cmd = m_generator.vertex(x, y); + if(is_stop(cmd)) { + m_status = accumulate; + break; + } + done = true; + break; + } + } + return cmd; +} +} +#endif diff --git a/third_party/agg23/agg_conv_dash.h b/third_party/agg23/agg_conv_dash.h new file mode 100644 index 0000000000..63b2019dde --- /dev/null +++ b/third_party/agg23/agg_conv_dash.h @@ -0,0 +1,61 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// conv_dash +// +//---------------------------------------------------------------------------- +#ifndef AGG_CONV_DASH_INCLUDED +#define AGG_CONV_DASH_INCLUDED +#include "agg_basics.h" +#include "agg_vcgen_dash.h" +#include "agg_conv_adaptor_vcgen.h" +namespace agg +{ +template +struct conv_dash : public conv_adaptor_vcgen { + typedef Markers marker_type; + typedef conv_adaptor_vcgen base_type; + conv_dash(VertexSource& vs) : + conv_adaptor_vcgen(vs) + { + } + void remove_all_dashes() + { + base_type::generator().remove_all_dashes(); + } + void add_dash(FX_FLOAT dash_len, FX_FLOAT gap_len) + { + base_type::generator().add_dash(dash_len, gap_len); + } + void dash_start(FX_FLOAT ds) + { + base_type::generator().dash_start(ds); + } + void shorten(FX_FLOAT s) + { + base_type::generator().shorten(s); + } + double shorten() const + { + return base_type::generator().shorten(); + } +private: + conv_dash(const conv_dash&); + const conv_dash& + operator = (const conv_dash&); +}; +} +#endif diff --git a/third_party/agg23/agg_conv_stroke.h b/third_party/agg23/agg_conv_stroke.h new file mode 100644 index 0000000000..5a36bd73bb --- /dev/null +++ b/third_party/agg23/agg_conv_stroke.h @@ -0,0 +1,110 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// conv_stroke +// +//---------------------------------------------------------------------------- +#ifndef AGG_CONV_STROKE_INCLUDED +#define AGG_CONV_STROKE_INCLUDED +#include "agg_basics.h" +#include "agg_vcgen_stroke.h" +#include "agg_conv_adaptor_vcgen.h" +namespace agg +{ +template +struct conv_stroke : + public conv_adaptor_vcgen { + typedef Markers marker_type; + typedef conv_adaptor_vcgen base_type; + conv_stroke(VertexSource& vs) : + conv_adaptor_vcgen(vs) + { + } + void line_cap(line_cap_e lc) + { + base_type::generator().line_cap(lc); + } + void line_join(line_join_e lj) + { + base_type::generator().line_join(lj); + } + void inner_join(inner_join_e ij) + { + base_type::generator().inner_join(ij); + } + line_cap_e line_cap() const + { + return base_type::generator().line_cap(); + } + line_join_e line_join() const + { + return base_type::generator().line_join(); + } + inner_join_e inner_join() const + { + return base_type::generator().inner_join(); + } + void width(FX_FLOAT w) + { + base_type::generator().width(w); + } + void miter_limit(FX_FLOAT ml) + { + base_type::generator().miter_limit(ml); + } + void miter_limit_theta(FX_FLOAT t) + { + base_type::generator().miter_limit_theta(t); + } + void inner_miter_limit(FX_FLOAT ml) + { + base_type::generator().inner_miter_limit(ml); + } + void approximation_scale(FX_FLOAT as) + { + base_type::generator().approximation_scale(as); + } + FX_FLOAT width() const + { + return base_type::generator().width(); + } + FX_FLOAT miter_limit() const + { + return base_type::generator().miter_limit(); + } + FX_FLOAT inner_miter_limit() const + { + return base_type::generator().inner_miter_limit(); + } + FX_FLOAT approximation_scale() const + { + return base_type::generator().approximation_scale(); + } + void shorten(FX_FLOAT s) + { + base_type::generator().shorten(s); + } + FX_FLOAT shorten() const + { + return base_type::generator().shorten(); + } +private: + conv_stroke(const conv_stroke&); + const conv_stroke& + operator = (const conv_stroke&); +}; +} +#endif diff --git a/third_party/agg23/agg_curves.cpp b/third_party/agg23/agg_curves.cpp new file mode 100644 index 0000000000..5a2d5631d6 --- /dev/null +++ b/third_party/agg23/agg_curves.cpp @@ -0,0 +1,109 @@ + +//---------------------------------------------------------------------------- +// XYQ: 2006-01-22 Copied from AGG project. +// TODO: This file uses intensive floating point operations, so it's NOT suitable +// for platforms like Symbian OS. We need to change to FIX format. +//---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#include "../../core/include/fxcrt/fx_basic.h" +#include "agg_curves.h" +#include "agg_math.h" +namespace agg +{ +const FX_FLOAT curve_collinearity_epsilon = 1e-30f; +enum curve_recursion_limit_e { curve_recursion_limit = 16 }; +void curve4_div::init(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) +{ + m_points.remove_all(); + m_distance_tolerance_square = 1.0f / 4; + m_distance_tolerance_manhattan = 1.0f * 4; + bezier(x1, y1, x2, y2, x3, y3, x4, y4); + m_count = 0; +} +void curve4_div::recursive_bezier(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4, + unsigned level) +{ + if(level > curve_recursion_limit) { + return; + } + FX_FLOAT x12 = (x1 + x2) / 2; + FX_FLOAT y12 = (y1 + y2) / 2; + FX_FLOAT x23 = (x2 + x3) / 2; + FX_FLOAT y23 = (y2 + y3) / 2; + FX_FLOAT x34 = (x3 + x4) / 2; + FX_FLOAT y34 = (y3 + y4) / 2; + FX_FLOAT x123 = (x12 + x23) / 2; + FX_FLOAT y123 = (y12 + y23) / 2; + FX_FLOAT x234 = (x23 + x34) / 2; + FX_FLOAT y234 = (y23 + y34) / 2; + FX_FLOAT x1234 = (x123 + x234) / 2; + FX_FLOAT y1234 = (y123 + y234) / 2; + FX_FLOAT dx = x4 - x1; + FX_FLOAT dy = y4 - y1; + FX_FLOAT d2 = FXSYS_fabs(FXSYS_Mul(x2 - x4, dy) - FXSYS_Mul(y2 - y4, dx)); + FX_FLOAT d3 = FXSYS_fabs(FXSYS_Mul(x3 - x4, dy) - FXSYS_Mul(y3 - y4, dx)); + switch((int(d2 > curve_collinearity_epsilon) << 1) + + int(d3 > curve_collinearity_epsilon)) { + case 0: + if(FXSYS_fabs(x1 + x3 - x2 - x2) + + FXSYS_fabs(y1 + y3 - y2 - y2) + + FXSYS_fabs(x2 + x4 - x3 - x3) + + FXSYS_fabs(y2 + y4 - y3 - y3) <= m_distance_tolerance_manhattan) { + m_points.add(point_type(x1234, y1234, path_flags_jr)); + return; + } + break; + case 1: + if(FXSYS_Mul(d3, d3) <= FXSYS_Mul(m_distance_tolerance_square, + FXSYS_Mul(dx, dx) + FXSYS_Mul(dy, dy))) { + m_points.add(point_type(x23, y23, path_flags_jr)); + return; + } + break; + case 2: + if(FXSYS_Mul(d2, d2) <= FXSYS_Mul(m_distance_tolerance_square, + FXSYS_Mul(dx, dx) + FXSYS_Mul(dy, dy))) { + m_points.add(point_type(x23, y23, path_flags_jr)); + return; + } + break; + case 3: + if(FXSYS_Mul(d2 + d3, d2 + d3) <= FXSYS_Mul(m_distance_tolerance_square, + FXSYS_Mul(dx, dx) + FXSYS_Mul(dy, dy))) { + m_points.add(point_type(x23, y23, path_flags_jr)); + return; + } + break; + } + recursive_bezier(x1, y1, x12, y12, x123, y123, x1234, y1234, level + 1); + recursive_bezier(x1234, y1234, x234, y234, x34, y34, x4, y4, level + 1); +} +void curve4_div::bezier(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) +{ + m_points.add(point_type(x1, y1)); + recursive_bezier(x1, y1, x2, y2, x3, y3, x4, y4, 0); + m_points.add(point_type(x4, y4)); +} +} diff --git a/third_party/agg23/agg_curves.h b/third_party/agg23/agg_curves.h new file mode 100644 index 0000000000..495f7a6a8f --- /dev/null +++ b/third_party/agg23/agg_curves.h @@ -0,0 +1,188 @@ + +//---------------------------------------------------------------------------- +// Anti-Grain Geometry - Version 2.3 +// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com) +// Copyright (C) 2005 Tony Juricic (tonygeek@yahoo.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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_CURVES_INCLUDED +#define AGG_CURVES_INCLUDED +#include "agg_array.h" +namespace agg +{ +struct curve4_points { + FX_FLOAT cp[8]; + curve4_points() {} + curve4_points(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) + { + cp[0] = x1; + cp[1] = y1; + cp[2] = x2; + cp[3] = y2; + cp[4] = x3; + cp[5] = y3; + cp[6] = x4; + cp[7] = y4; + } + void init(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) + { + cp[0] = x1; + cp[1] = y1; + cp[2] = x2; + cp[3] = y2; + cp[4] = x3; + cp[5] = y3; + cp[6] = x4; + cp[7] = y4; + } + FX_FLOAT operator [] (unsigned i) const + { + return cp[i]; + } + FX_FLOAT& operator [] (unsigned i) + { + return cp[i]; + } +}; +class curve4_div +{ +public: + curve4_div() : + m_count(0) + {} + curve4_div(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) : + m_count(0) + { + init(x1, y1, x2, y2, x3, y3, x4, y4); + } + curve4_div(const curve4_points& cp) : + m_count(0) + { + init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); + } + void reset() + { + m_points.remove_all(); + m_count = 0; + } + void init(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4); + void init(const curve4_points& cp) + { + init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); + } + void rewind(unsigned) + { + m_count = 0; + } + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + { + if(m_count >= m_points.size()) { + return path_cmd_stop; + } + const point_type& p = m_points[m_count++]; + *x = p.x; + *y = p.y; + return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to; + } + unsigned vertex_flag(FX_FLOAT* x, FX_FLOAT* y, int& flag) + { + if(m_count >= m_points.size()) { + return path_cmd_stop; + } + const point_type& p = m_points[m_count++]; + *x = p.x; + *y = p.y; + flag = p.flag; + return (m_count == 1) ? path_cmd_move_to : path_cmd_line_to; + } + int count() + { + return m_points.size(); + } +private: + void bezier(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4); + void recursive_bezier(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4, + unsigned level); + FX_FLOAT m_distance_tolerance_square; + FX_FLOAT m_distance_tolerance_manhattan; + unsigned m_count; + pod_deque m_points; +}; +class curve4 +{ +public: + curve4() {} + curve4(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) + { + init(x1, y1, x2, y2, x3, y3, x4, y4); + } + curve4(const curve4_points& cp) + { + init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); + } + void reset() + { + m_curve_div.reset(); + } + void init(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x3, FX_FLOAT y3, + FX_FLOAT x4, FX_FLOAT y4) + { + m_curve_div.init(x1, y1, x2, y2, x3, y3, x4, y4); + } + void init(const curve4_points& cp) + { + init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); + } + void rewind(unsigned path_id) + { + m_curve_div.rewind(path_id); + } + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + { + return m_curve_div.vertex(x, y); + } + unsigned vertex_curve_flag(FX_FLOAT* x, FX_FLOAT* y, int& flag) + { + return m_curve_div.vertex_flag(x, y, flag); + } + int count() + { + return m_curve_div.count(); + } +private: + curve4_div m_curve_div; +}; +} +#endif diff --git a/third_party/agg23/agg_math.h b/third_party/agg23/agg_math.h new file mode 100644 index 0000000000..31e0daf3bb --- /dev/null +++ b/third_party/agg23/agg_math.h @@ -0,0 +1,63 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// Bessel function (besj) was adapted for use in AGG library by Andy Wilk +// Contact: castor.vulgaris@gmail.com +//---------------------------------------------------------------------------- +#ifndef AGG_MATH_INCLUDED +#define AGG_MATH_INCLUDED +#include "agg_basics.h" +namespace agg +{ +const FX_FLOAT intersection_epsilon = 1.0e-30f; +AGG_INLINE FX_FLOAT calc_point_location(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x, FX_FLOAT y) +{ + return FXSYS_Mul(x - x2, y2 - y1) - FXSYS_Mul(y - y2, x2 - x1); +} +AGG_INLINE FX_FLOAT calc_distance(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2) +{ + FX_FLOAT dx = x2 - x1; + FX_FLOAT dy = y2 - y1; + return FXSYS_sqrt2(dx, dy); +} +AGG_INLINE FX_FLOAT calc_line_point_distance(FX_FLOAT x1, FX_FLOAT y1, + FX_FLOAT x2, FX_FLOAT y2, + FX_FLOAT x, FX_FLOAT y) +{ + FX_FLOAT dx = x2 - x1; + FX_FLOAT dy = y2 - y1; + FX_FLOAT d = FXSYS_sqrt2(dx, dy); + if(d < intersection_epsilon) { + return calc_distance(x1, y1, x, y); + } + return FXSYS_MulDiv(x - x2, dy, d) - FXSYS_MulDiv(y - y2, dx, d); +} +AGG_INLINE bool calc_intersection(FX_FLOAT ax, FX_FLOAT ay, FX_FLOAT bx, FX_FLOAT by, + FX_FLOAT cx, FX_FLOAT cy, FX_FLOAT dx, FX_FLOAT dy, + FX_FLOAT* x, FX_FLOAT* y) +{ + FX_FLOAT num = FXSYS_Mul(ay - cy, dx - cx) - FXSYS_Mul(ax - cx, dy - cy); + FX_FLOAT den = FXSYS_Mul(bx - ax, dy - cy) - FXSYS_Mul(by - ay, dx - cx); + if (FXSYS_fabs(den) < intersection_epsilon) { + return false; + } + *x = ax + FXSYS_MulDiv(bx - ax, num, den); + *y = ay + FXSYS_MulDiv(by - ay, num, den); + return true; +} +} +#endif diff --git a/third_party/agg23/agg_math_stroke.h b/third_party/agg23/agg_math_stroke.h new file mode 100644 index 0000000000..620d675312 --- /dev/null +++ b/third_party/agg23/agg_math_stroke.h @@ -0,0 +1,272 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Stroke math +// +//---------------------------------------------------------------------------- +#ifndef AGG_STROKE_MATH_INCLUDED +#define AGG_STROKE_MATH_INCLUDED +#include "agg_math.h" +#include "agg_vertex_sequence.h" +namespace agg +{ +enum line_cap_e { + butt_cap, + square_cap, + round_cap +}; +enum line_join_e { + miter_join = 0, + miter_join_revert = 1, + miter_join_round = 4, + round_join = 2, + bevel_join = 3 +}; +enum inner_join_e { + inner_bevel, + inner_miter, + inner_jag, + inner_round +}; +const FX_FLOAT stroke_theta = 1.0f / 1000.0f; +template +void stroke_calc_arc(VertexConsumer& out_vertices, + FX_FLOAT x, FX_FLOAT y, + FX_FLOAT dx1, FX_FLOAT dy1, + FX_FLOAT dx2, FX_FLOAT dy2, + FX_FLOAT width, + FX_FLOAT approximation_scale) +{ + typedef typename VertexConsumer::value_type coord_type; + FX_FLOAT a1 = FXSYS_atan2(dy1, dx1); + FX_FLOAT a2 = FXSYS_atan2(dy2, dx2); + FX_FLOAT da = a1 - a2; + bool ccw = da > 0 && da < FX_PI; + if(width < 0) { + width = -width; + } + da = FXSYS_acos(FXSYS_Div(width, width + FXSYS_Div(1.0f / 8, approximation_scale))) * 2; + out_vertices.add(coord_type(x + dx1, y + dy1)); + if(!ccw) { + if(a1 > a2) { + a2 += 2 * FX_PI; + } + a2 -= da / 4; + a1 += da; + while(a1 < a2) { + out_vertices.add(coord_type(x + FXSYS_Mul(width, FXSYS_cos(a1)), + y + FXSYS_Mul(width, FXSYS_sin(a1)))); + a1 += da; + } + } else { + if(a1 < a2) { + a2 -= 2 * FX_PI; + } + a2 += da / 4; + a1 -= da; + while(a1 > a2) { + out_vertices.add(coord_type(x + FXSYS_Mul(width, FXSYS_cos(a1)), + y + FXSYS_Mul(width, FXSYS_sin(a1)))); + a1 -= da; + } + } + out_vertices.add(coord_type(x + dx2, y + dy2)); +} +template +void stroke_calc_miter(VertexConsumer& out_vertices, + const vertex_dist& v0, + const vertex_dist& v1, + const vertex_dist& v2, + FX_FLOAT dx1, FX_FLOAT dy1, + FX_FLOAT dx2, FX_FLOAT dy2, + FX_FLOAT width, + line_join_e line_join, + FX_FLOAT miter_limit, + FX_FLOAT approximation_scale) +{ + typedef typename VertexConsumer::value_type coord_type; + FX_FLOAT xi = v1.x; + FX_FLOAT yi = v1.y; + bool miter_limit_exceeded = true; + if(calc_intersection(v0.x + dx1, v0.y - dy1, + v1.x + dx1, v1.y - dy1, + v1.x + dx2, v1.y - dy2, + v2.x + dx2, v2.y - dy2, + &xi, &yi)) { + FX_FLOAT d1 = calc_distance(v1.x, v1.y, xi, yi); + FX_FLOAT lim = FXSYS_Mul(width, miter_limit); + if(d1 <= lim) { + out_vertices.add(coord_type(xi, yi)); + miter_limit_exceeded = false; + } + } else { + FX_FLOAT x2 = v1.x + dx1; + FX_FLOAT y2 = v1.y - dy1; + if((FXSYS_Mul(x2 - v0.x, dy1) - FXSYS_Mul(v0.y - y2, dx1) < 0) != + (FXSYS_Mul(x2 - v2.x, dy1) - FXSYS_Mul(v2.y - y2, dx1) < 0)) { + out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); + miter_limit_exceeded = false; + } + } + if(miter_limit_exceeded) { + switch(line_join) { + case miter_join_revert: + out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); + out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2)); + break; + case miter_join_round: + stroke_calc_arc(out_vertices, + v1.x, v1.y, dx1, -dy1, dx2, -dy2, + width, approximation_scale); + break; + default: + out_vertices.add(coord_type(v1.x + dx1 + FXSYS_Mul(dy1, miter_limit), + v1.y - dy1 + FXSYS_Mul(dx1, miter_limit))); + out_vertices.add(coord_type(v1.x + dx2 - FXSYS_Mul(dy2, miter_limit), + v1.y - dy2 - FXSYS_Mul(dx2, miter_limit))); + break; + } + } +} +template +void stroke_calc_cap(VertexConsumer& out_vertices, + const vertex_dist& v0, + const vertex_dist& v1, + FX_FLOAT len, + line_cap_e line_cap, + FX_FLOAT width, + FX_FLOAT approximation_scale) +{ + typedef typename VertexConsumer::value_type coord_type; + out_vertices.remove_all(); + FX_FLOAT dx1 = FXSYS_Div(v1.y - v0.y, len); + FX_FLOAT dy1 = FXSYS_Div(v1.x - v0.x, len); + FX_FLOAT dx2 = 0; + FX_FLOAT dy2 = 0; + dx1 = FXSYS_Mul(dx1, width); + dy1 = FXSYS_Mul(dy1, width); + if(line_cap != round_cap) { + if(line_cap == square_cap) { + dx2 = dy1; + dy2 = dx1; + } + out_vertices.add(coord_type(v0.x - dx1 - dx2, v0.y + dy1 - dy2)); + out_vertices.add(coord_type(v0.x + dx1 - dx2, v0.y - dy1 - dy2)); + } else { + FX_FLOAT a1 = FXSYS_atan2(dy1, -dx1); + FX_FLOAT a2 = a1 + FX_PI; + FX_FLOAT da = FXSYS_acos(FXSYS_Div(width, width + + FXSYS_Div(1.0f / 8, approximation_scale))) * 2; + out_vertices.add(coord_type(v0.x - dx1, v0.y + dy1)); + a1 += da; + a2 -= da / 4; + while(a1 < a2) { + out_vertices.add(coord_type(v0.x + FXSYS_Mul(width, FXSYS_cos(a1)), + v0.y + FXSYS_Mul(width, FXSYS_sin(a1)))); + a1 += da; + } + out_vertices.add(coord_type(v0.x + dx1, v0.y - dy1)); + } +} +template +void stroke_calc_join(VertexConsumer& out_vertices, + const vertex_dist& v0, + const vertex_dist& v1, + const vertex_dist& v2, + FX_FLOAT len1, + FX_FLOAT len2, + FX_FLOAT width, + line_join_e line_join, + inner_join_e inner_join, + FX_FLOAT miter_limit, + FX_FLOAT inner_miter_limit, + FX_FLOAT approximation_scale) +{ + typedef typename VertexConsumer::value_type coord_type; + FX_FLOAT dx1, dy1, dx2, dy2; + dx1 = FXSYS_MulDiv(width, v1.y - v0.y, len1); + dy1 = FXSYS_MulDiv(width, v1.x - v0.x, len1); + dx2 = FXSYS_MulDiv(width, v2.y - v1.y, len2); + dy2 = FXSYS_MulDiv(width, v2.x - v1.x, len2); + out_vertices.remove_all(); + if(calc_point_location(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y) > 0) { + switch(inner_join) { + default: + out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); + out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2)); + break; + case inner_miter: + stroke_calc_miter(out_vertices, + v0, v1, v2, dx1, dy1, dx2, dy2, + width, + miter_join_revert, + inner_miter_limit, + 1.0f); + break; + case inner_jag: + case inner_round: { + FX_FLOAT d = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2); + if(d < len1 * len1 && d < len2 * len2) { + stroke_calc_miter(out_vertices, + v0, v1, v2, dx1, dy1, dx2, dy2, + width, + miter_join_revert, + inner_miter_limit, + 1.0f); + } else { + if(inner_join == inner_jag) { + out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); + out_vertices.add(coord_type(v1.x, v1.y )); + out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2)); + } else { + out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); + out_vertices.add(coord_type(v1.x, v1.y )); + stroke_calc_arc(out_vertices, + v1.x, v1.y, dx2, -dy2, dx1, -dy1, + width, approximation_scale); + out_vertices.add(coord_type(v1.x, v1.y )); + out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2)); + } + } + } + break; + } + } else { + switch(line_join) { + case miter_join: + case miter_join_revert: + case miter_join_round: + stroke_calc_miter(out_vertices, + v0, v1, v2, dx1, dy1, dx2, dy2, + width, + line_join, + miter_limit, + approximation_scale); + break; + case round_join: + stroke_calc_arc(out_vertices, + v1.x, v1.y, dx1, -dy1, dx2, -dy2, + width, approximation_scale); + break; + default: + out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); + out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2)); + break; + } + } +} +} +#endif diff --git a/third_party/agg23/agg_path_storage.cpp b/third_party/agg23/agg_path_storage.cpp new file mode 100644 index 0000000000..f5c9843e58 --- /dev/null +++ b/third_party/agg23/agg_path_storage.cpp @@ -0,0 +1,98 @@ + +//---------------------------------------------------------------------------- +// XYQ: 2006-01-22 Copied from AGG project. +// TODO: This file uses intensive floating point operations, so it's NOT suitable +// for platforms like Symbian OS. We need to change to FIX format. +//---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Class path_storage +// +//---------------------------------------------------------------------------- +#include "../../core/include/fxcrt/fx_basic.h" +#include "agg_path_storage.h" +#include "agg_math.h" +namespace agg +{ +path_storage::~path_storage() +{ + if(m_total_blocks) { + FX_FLOAT** coord_blk = m_coord_blocks + m_total_blocks - 1; + while(m_total_blocks--) { + FX_Free(*coord_blk); + --coord_blk; + } + FX_Free(m_coord_blocks); + } +} +path_storage::path_storage() : + m_total_vertices(0), + m_total_blocks(0), + m_max_blocks(0), + m_coord_blocks(0), + m_cmd_blocks(0), + m_iterator(0) +{ +} +void path_storage::allocate_block(unsigned nb) +{ + if(nb >= m_max_blocks) { + FX_FLOAT** new_coords = + FX_Alloc2D(FX_FLOAT*, m_max_blocks + block_pool, 2); + unsigned char** new_cmds = + (unsigned char**)(new_coords + m_max_blocks + block_pool); + if(m_coord_blocks) { + FXSYS_memcpy(new_coords, + m_coord_blocks, + m_max_blocks * sizeof(FX_FLOAT*)); + FXSYS_memcpy(new_cmds, + m_cmd_blocks, + m_max_blocks * sizeof(unsigned char*)); + FX_Free(m_coord_blocks); + } + m_coord_blocks = new_coords; + m_cmd_blocks = new_cmds; + m_max_blocks += block_pool; + } + m_coord_blocks[nb] = + FX_Alloc( FX_FLOAT, block_size * 2 + + block_size / + (sizeof(FX_FLOAT) / sizeof(unsigned char))); + m_cmd_blocks[nb] = + (unsigned char*)(m_coord_blocks[nb] + block_size * 2); + m_total_blocks++; +} +void path_storage::rewind(unsigned path_id) +{ + m_iterator = path_id; +} +void path_storage::curve4(FX_FLOAT x_ctrl1, FX_FLOAT y_ctrl1, + FX_FLOAT x_ctrl2, FX_FLOAT y_ctrl2, + FX_FLOAT x_to, FX_FLOAT y_to) +{ + add_vertex(x_ctrl1, y_ctrl1, path_cmd_curve4); + add_vertex(x_ctrl2, y_ctrl2, path_cmd_curve4); + add_vertex(x_to, y_to, path_cmd_curve4); +} +void path_storage::end_poly() +{ + if(m_total_vertices) { + if(is_vertex(command(m_total_vertices - 1))) { + add_vertex(0, 0, path_cmd_end_poly | path_flags_close); + } + } +} +} diff --git a/third_party/agg23/agg_path_storage.h b/third_party/agg23/agg_path_storage.h new file mode 100644 index 0000000000..dc13851d09 --- /dev/null +++ b/third_party/agg23/agg_path_storage.h @@ -0,0 +1,172 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_PATH_STORAGE_INCLUDED +#define AGG_PATH_STORAGE_INCLUDED +#include "agg_basics.h" +namespace agg +{ +class path_storage +{ + enum block_scale_e { + block_shift = 8, + block_size = 1 << block_shift, + block_mask = block_size - 1, + block_pool = 256 + }; +public: + class vertex_source + { + public: + vertex_source() {} + vertex_source(const path_storage& p) : m_path(&p), m_vertex_idx(0) {} + void rewind(unsigned path_id) + { + m_vertex_idx = path_id; + } + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + { + return (m_vertex_idx < m_path->total_vertices()) ? + m_path->vertex(m_vertex_idx++, x, y) : + path_cmd_stop; + } + private: + const path_storage* m_path; + unsigned m_vertex_idx; + }; + ~path_storage(); + path_storage(); + unsigned last_vertex(FX_FLOAT* x, FX_FLOAT* y) const; + unsigned prev_vertex(FX_FLOAT* x, FX_FLOAT* y) const; + void move_to(FX_FLOAT x, FX_FLOAT y); + void line_to(FX_FLOAT x, FX_FLOAT y); + void curve4(FX_FLOAT x_ctrl1, FX_FLOAT y_ctrl1, + FX_FLOAT x_ctrl2, FX_FLOAT y_ctrl2, + FX_FLOAT x_to, FX_FLOAT y_to); + template + void add_path(VertexSource& vs, + unsigned path_id = 0, + bool solid_path = true) + { + FX_FLOAT x, y; + unsigned cmd; + vs.rewind(path_id); + while(!is_stop(cmd = vs.vertex(&x, &y))) { + if(is_move_to(cmd) && solid_path && m_total_vertices) { + cmd = path_cmd_line_to; + } + add_vertex(x, y, cmd); + } + } + template + void add_path_curve(VertexSource& vs, + unsigned path_id = 0, + bool solid_path = true) + { + FX_FLOAT x, y; + unsigned cmd; + int flag; + vs.rewind(path_id); + while(!is_stop(cmd = vs.vertex_curve_flag(&x, &y, flag))) { + if(is_move_to(cmd) && solid_path && m_total_vertices) { + cmd = path_cmd_line_to | flag; + } + add_vertex(x, y, cmd | flag); + } + } + unsigned total_vertices() const + { + return m_total_vertices; + } + unsigned vertex(unsigned idx, FX_FLOAT* x, FX_FLOAT* y) const + { + unsigned nb = idx >> block_shift; + const FX_FLOAT* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1); + *x = *pv++; + *y = *pv; + return m_cmd_blocks[nb][idx & block_mask]; + } + unsigned command(unsigned idx) const + { + return m_cmd_blocks[idx >> block_shift][idx & block_mask]; + } + unsigned getflag(unsigned idx) const + { + return m_cmd_blocks[idx >> block_shift][idx & block_mask] & path_flags_jr; + } + void rewind(unsigned path_id); + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); + void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd); + void end_poly(); +private: + void allocate_block(unsigned nb); + unsigned char* storage_ptrs(FX_FLOAT** xy_ptr); +private: + unsigned m_total_vertices; + unsigned m_total_blocks; + unsigned m_max_blocks; + FX_FLOAT** m_coord_blocks; + unsigned char** m_cmd_blocks; + unsigned m_iterator; +}; +inline unsigned path_storage::vertex(FX_FLOAT* x, FX_FLOAT* y) +{ + if(m_iterator >= m_total_vertices) { + return path_cmd_stop; + } + return vertex(m_iterator++, x, y); +} +inline unsigned path_storage::prev_vertex(FX_FLOAT* x, FX_FLOAT* y) const +{ + if(m_total_vertices > 1) { + return vertex(m_total_vertices - 2, x, y); + } + return path_cmd_stop; +} +inline unsigned path_storage::last_vertex(FX_FLOAT* x, FX_FLOAT* y) const +{ + if(m_total_vertices) { + return vertex(m_total_vertices - 1, x, y); + } + return path_cmd_stop; +} +inline unsigned char* path_storage::storage_ptrs(FX_FLOAT** xy_ptr) +{ + unsigned nb = m_total_vertices >> block_shift; + if(nb >= m_total_blocks) { + allocate_block(nb); + } + *xy_ptr = m_coord_blocks[nb] + ((m_total_vertices & block_mask) << 1); + return m_cmd_blocks[nb] + (m_total_vertices & block_mask); +} +inline void path_storage::add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) +{ + FX_FLOAT* coord_ptr = 0; + unsigned char* cmd_ptr = storage_ptrs(&coord_ptr); + *cmd_ptr = (unsigned char)cmd; + *coord_ptr++ = x; + *coord_ptr = y; + m_total_vertices++; +} +inline void path_storage::move_to(FX_FLOAT x, FX_FLOAT y) +{ + add_vertex(x, y, path_cmd_move_to); +} +inline void path_storage::line_to(FX_FLOAT x, FX_FLOAT y) +{ + add_vertex(x, y, path_cmd_line_to); +} +} +#endif diff --git a/third_party/agg23/agg_pixfmt_gray.h b/third_party/agg23/agg_pixfmt_gray.h new file mode 100644 index 0000000000..5a80935479 --- /dev/null +++ b/third_party/agg23/agg_pixfmt_gray.h @@ -0,0 +1,177 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Adaptation for high precision colors 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_PIXFMT_GRAY_INCLUDED +#define AGG_PIXFMT_GRAY_INCLUDED +#include "agg_basics.h" +#include "agg_color_gray.h" +#include "agg_rendering_buffer.h" +namespace agg +{ +template struct blender_gray { + typedef ColorT color_type; + typedef typename color_type::value_type value_type; + typedef typename color_type::calc_type calc_type; + enum base_scale_e { base_shift = color_type::base_shift }; + static AGG_INLINE void blend_pix(value_type* p, unsigned cv, + unsigned alpha, unsigned cover = 0) + { + *p = (value_type)((((cv - calc_type(*p)) * alpha) + (calc_type(*p) << base_shift)) >> base_shift); + } +}; +template +class pixel_formats_gray +{ +public: + typedef rendering_buffer::row_data row_data; + typedef rendering_buffer::span_data span_data; + typedef typename Blender::color_type color_type; + typedef typename color_type::value_type value_type; + typedef typename color_type::calc_type calc_type; + enum base_scale_e { + base_shift = color_type::base_shift, + base_size = color_type::base_size, + base_mask = color_type::base_mask + }; +private: + static AGG_INLINE void copy_or_blend_pix(value_type* p, + const color_type& c, + unsigned cover) + { + if (c.a) { + calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8; + if(alpha == base_mask) { + *p = c.v; + } else { + Blender::blend_pix(p, c.v, alpha, cover); + } + } + } + static AGG_INLINE void copy_or_blend_pix(value_type* p, + const color_type& c) + { + if (c.a) { + if(c.a == base_mask) { + *p = c.v; + } else { + Blender::blend_pix(p, c.v, c.a); + } + } + } +public: + pixel_formats_gray(rendering_buffer& rb) : + m_rbuf(&rb) + {} + AGG_INLINE unsigned width() const + { + return m_rbuf->width(); + } + AGG_INLINE unsigned height() const + { + return m_rbuf->height(); + } + AGG_INLINE color_type pixel(int x, int y) const + { + value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset; + return color_type(*p); + } + row_data row(int x, int y) const + { + return row_data(x, + width() - 1, + m_rbuf->row(y) + + x * Step * sizeof(value_type) + + Offset * sizeof(value_type)); + } + span_data span(int x, int y, unsigned len) + { + return span_data(x, len, + m_rbuf->row(y) + + x * Step * sizeof(value_type) + + Offset * sizeof(value_type)); + } + AGG_INLINE void copy_pixel(int x, int y, const color_type& c) + { + *((value_type*)m_rbuf->row(y) + x * Step + Offset) = c.v; + } + AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover) + { + copy_or_blend_pix((value_type*)m_rbuf->row(y) + x * Step + Offset, c, cover); + } + AGG_INLINE void copy_hline(int x, int y, + unsigned len, + const color_type& c) + { + value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset; + do { + *p = c.v; + p += Step; + } while(--len); + } + void blend_hline(int x, int y, + unsigned len, + const color_type& c, + int8u cover) + { + if (c.a) { + value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset; + calc_type alpha = (calc_type(c.a) * (cover + 1)) >> 8; + if(alpha == base_mask) { + do { + *p = c.v; + p += Step; + } while(--len); + } else { + do { + Blender::blend_pix(p, c.v, alpha, cover); + p += Step; + } while(--len); + } + } + } + void blend_solid_hspan(int x, int y, + unsigned len, + const color_type& c, + const int8u* covers) + { + if (c.a) { + value_type* p = (value_type*)m_rbuf->row(y) + x * Step + Offset; + do { + calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8; + if(alpha == base_mask) { + *p = c.v; + } else { + Blender::blend_pix(p, c.v, alpha, *covers); + } + p += Step; + ++covers; + } while(--len); + } + } +private: + rendering_buffer* m_rbuf; +}; +typedef blender_gray blender_gray8; +typedef pixel_formats_gray pixfmt_gray8; +} +#endif diff --git a/third_party/agg23/agg_rasterizer_scanline_aa.cpp b/third_party/agg23/agg_rasterizer_scanline_aa.cpp new file mode 100644 index 0000000000..8216e60221 --- /dev/null +++ b/third_party/agg23/agg_rasterizer_scanline_aa.cpp @@ -0,0 +1,489 @@ + +//---------------------------------------------------------------------------- +// XYQ: 2006-01-22 Copied from AGG project. +// This file uses only integer data, so it's suitable for all platforms. +//---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// +// Class outline_aa - implementation. +// +// Initially the rendering algorithm was designed by David Turner and the +// other authors of the FreeType library - see the above notice. I nearly +// created a similar renderer, but still I was far from David's work. +// I completely redesigned the original code and adapted it for Anti-Grain +// ideas. Two functions - render_line and render_hline are the core of +// the algorithm - they calculate the exact coverage of each pixel cell +// of the polygon. I left these functions almost as is, because there's +// no way to improve the perfection - hats off to David and his group! +// +// All other code is very different from the original. +// +//---------------------------------------------------------------------------- +#include "../../core/include/fxcrt/fx_ext.h" +#include +#include "agg_rasterizer_scanline_aa.h" +namespace agg +{ +AGG_INLINE void cell_aa::set_cover(int c, int a) +{ + cover = c; + area = a; +} +AGG_INLINE void cell_aa::add_cover(int c, int a) +{ + cover += c; + area += a; +} +AGG_INLINE void cell_aa::set_coord(int cx, int cy) +{ + x = cx; + y = cy; +} +AGG_INLINE void cell_aa::set(int cx, int cy, int c, int a) +{ + x = cx; + y = cy; + cover = c; + area = a; +} +outline_aa::~outline_aa() +{ + if(m_num_blocks) { + cell_aa** ptr = m_cells + m_num_blocks - 1; + while(m_num_blocks--) { + FX_Free(*ptr); + ptr--; + } + FX_Free(m_cells); + } +} +outline_aa::outline_aa() : + m_num_blocks(0), + m_max_blocks(0), + m_cur_block(0), + m_num_cells(0), + m_cells(0), + m_cur_cell_ptr(0), + m_cur_x(0), + m_cur_y(0), + m_min_x(0x7FFFFFFF), + m_min_y(0x7FFFFFFF), + m_max_x(-0x7FFFFFFF), + m_max_y(-0x7FFFFFFF), + m_sorted(false) +{ + m_cur_cell.set(0x7FFF, 0x7FFF, 0, 0); +} +void outline_aa::reset() +{ + m_num_cells = 0; + m_cur_block = 0; + m_cur_cell.set(0x7FFF, 0x7FFF, 0, 0); + m_sorted = false; + m_min_x = 0x7FFFFFFF; + m_min_y = 0x7FFFFFFF; + m_max_x = -0x7FFFFFFF; + m_max_y = -0x7FFFFFFF; +} +void outline_aa::allocate_block() +{ + if(m_cur_block >= m_num_blocks) { + if(m_num_blocks >= m_max_blocks) { + cell_aa** new_cells = FX_Alloc( cell_aa*, m_max_blocks + cell_block_pool); + if(m_cells) { + FXSYS_memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_aa*)); + FX_Free(m_cells); + } + m_cells = new_cells; + m_max_blocks += cell_block_pool; + } + m_cells[m_num_blocks++] = FX_Alloc(cell_aa, cell_block_size); + } + m_cur_cell_ptr = m_cells[m_cur_block++]; +} +AGG_INLINE void outline_aa::add_cur_cell() +{ + if(m_cur_cell.area | m_cur_cell.cover) { + if((m_num_cells & cell_block_mask) == 0) { + if(m_num_blocks >= cell_block_limit) { + return; + } + allocate_block(); + } + *m_cur_cell_ptr++ = m_cur_cell; + ++m_num_cells; + } +} +AGG_INLINE void outline_aa::set_cur_cell(int x, int y) +{ + if(m_cur_cell.x != x || m_cur_cell.y != y) { + add_cur_cell(); + m_cur_cell.set(x, y, 0, 0); + if(x < m_min_x) { + m_min_x = x; + } + if(x > m_max_x) { + m_max_x = x; + } + if(y < m_min_y) { + m_min_y = y; + } + if(y > m_max_y) { + m_max_y = y; + } + } +} +AGG_INLINE void outline_aa::render_hline(int ey, int x1, int y1, int x2, int y2) +{ + int ex1 = x1 >> poly_base_shift; + int ex2 = x2 >> poly_base_shift; + int fx1 = x1 & poly_base_mask; + int fx2 = x2 & poly_base_mask; + int delta, p, first, dx; + int incr, lift, mod, rem; + if(y1 == y2) { + set_cur_cell(ex2, ey); + return; + } + if(ex1 == ex2) { + delta = y2 - y1; + m_cur_cell.add_cover(delta, (fx1 + fx2) * delta); + return; + } + p = (poly_base_size - fx1) * (y2 - y1); + first = poly_base_size; + incr = 1; + dx = x2 - x1; + if(dx < 0) { + p = fx1 * (y2 - y1); + first = 0; + incr = -1; + dx = -dx; + } + delta = p / dx; + mod = p % dx; + if(mod < 0) { + delta--; + mod += dx; + } + m_cur_cell.add_cover(delta, (fx1 + first) * delta); + ex1 += incr; + set_cur_cell(ex1, ey); + y1 += delta; + if(ex1 != ex2) { + p = poly_base_size * (y2 - y1 + delta); + lift = p / dx; + rem = p % dx; + if (rem < 0) { + lift--; + rem += dx; + } + mod -= dx; + while (ex1 != ex2) { + delta = lift; + mod += rem; + if(mod >= 0) { + mod -= dx; + delta++; + } + m_cur_cell.add_cover(delta, (poly_base_size) * delta); + y1 += delta; + ex1 += incr; + set_cur_cell(ex1, ey); + } + } + delta = y2 - y1; + m_cur_cell.add_cover(delta, (fx2 + poly_base_size - first) * delta); +} +void outline_aa::render_line(int x1, int y1, int x2, int y2) +{ + enum dx_limit_e { dx_limit = 16384 << poly_base_shift }; + int dx = x2 - x1; + if(dx >= dx_limit || dx <= -dx_limit) { + int cx = (x1 + x2) >> 1; + int cy = (y1 + y2) >> 1; + render_line(x1, y1, cx, cy); + render_line(cx, cy, x2, y2); + } + int dy = y2 - y1; + int ey1 = y1 >> poly_base_shift; + int ey2 = y2 >> poly_base_shift; + int fy1 = y1 & poly_base_mask; + int fy2 = y2 & poly_base_mask; + int x_from, x_to; + int p, rem, mod, lift, delta, first, incr; + if(ey1 == ey2) { + render_hline(ey1, x1, fy1, x2, fy2); + return; + } + incr = 1; + if(dx == 0) { + int ex = x1 >> poly_base_shift; + int two_fx = (x1 - (ex << poly_base_shift)) << 1; + int area; + first = poly_base_size; + if(dy < 0) { + first = 0; + incr = -1; + } + x_from = x1; + delta = first - fy1; + m_cur_cell.add_cover(delta, two_fx * delta); + ey1 += incr; + set_cur_cell(ex, ey1); + delta = first + first - poly_base_size; + area = two_fx * delta; + while(ey1 != ey2) { + m_cur_cell.set_cover(delta, area); + ey1 += incr; + set_cur_cell(ex, ey1); + } + delta = fy2 - poly_base_size + first; + m_cur_cell.add_cover(delta, two_fx * delta); + return; + } + p = (poly_base_size - fy1) * dx; + first = poly_base_size; + if(dy < 0) { + p = fy1 * dx; + first = 0; + incr = -1; + dy = -dy; + } + delta = p / dy; + mod = p % dy; + if(mod < 0) { + delta--; + mod += dy; + } + x_from = x1 + delta; + render_hline(ey1, x1, fy1, x_from, first); + ey1 += incr; + set_cur_cell(x_from >> poly_base_shift, ey1); + if(ey1 != ey2) { + p = poly_base_size * dx; + lift = p / dy; + rem = p % dy; + if(rem < 0) { + lift--; + rem += dy; + } + mod -= dy; + while(ey1 != ey2) { + delta = lift; + mod += rem; + if (mod >= 0) { + mod -= dy; + delta++; + } + x_to = x_from + delta; + render_hline(ey1, x_from, poly_base_size - first, x_to, first); + x_from = x_to; + ey1 += incr; + set_cur_cell(x_from >> poly_base_shift, ey1); + } + } + render_hline(ey1, x_from, poly_base_size - first, x2, fy2); +} +void outline_aa::move_to(int x, int y) +{ + if(m_sorted) { + reset(); + } + set_cur_cell(x >> poly_base_shift, y >> poly_base_shift); + m_cur_x = x; + m_cur_y = y; +} +void outline_aa::line_to(int x, int y) +{ + render_line(m_cur_x, m_cur_y, x, y); + m_cur_x = x; + m_cur_y = y; + m_sorted = false; +} +template static AGG_INLINE void swap_cells(T* a, T* b) +{ + T temp = *a; + *a = *b; + *b = temp; +} +enum { + qsort_threshold = 9 +}; +static void qsort_cells(cell_aa** start, unsigned num) +{ + cell_aa** stack[80]; + cell_aa*** top; + cell_aa** limit; + cell_aa** base; + limit = start + num; + base = start; + top = stack; + for (;;) { + int len = int(limit - base); + cell_aa** i; + cell_aa** j; + cell_aa** pivot; + if(len > qsort_threshold) { + pivot = base + len / 2; + swap_cells(base, pivot); + i = base + 1; + j = limit - 1; + if((*j)->x < (*i)->x) { + swap_cells(i, j); + } + if((*base)->x < (*i)->x) { + swap_cells(base, i); + } + if((*j)->x < (*base)->x) { + swap_cells(base, j); + } + for(;;) { + int x = (*base)->x; + do { + i++; + } while( (*i)->x < x ); + do { + j--; + } while( x < (*j)->x ); + if(i > j) { + break; + } + swap_cells(i, j); + } + swap_cells(base, j); + if(j - base > limit - i) { + top[0] = base; + top[1] = j; + base = i; + } else { + top[0] = i; + top[1] = limit; + limit = j; + } + top += 2; + } else { + j = base; + i = j + 1; + for(; i < limit; j = i, i++) { + for(; j[1]->x < (*j)->x; j--) { + swap_cells(j + 1, j); + if (j == base) { + break; + } + } + } + if(top > stack) { + top -= 2; + base = top[0]; + limit = top[1]; + } else { + break; + } + } + } +} +void outline_aa::sort_cells() +{ + if(m_sorted) { + return; + } + add_cur_cell(); + if(m_num_cells == 0) { + return; + } + m_sorted_cells.allocate(m_num_cells, 16); + if (m_max_y > 0 && m_min_y < 0 && -m_min_y > INT_MAX - m_max_y) { + return; + } + unsigned size = m_max_y - m_min_y; + if (size + 1 < size) { + return; + } + size++; + m_sorted_y.allocate(size, 16); + m_sorted_y.zero(); + cell_aa** block_ptr = m_cells; + cell_aa* cell_ptr = NULL; + unsigned nb = m_num_cells >> cell_block_shift; + unsigned i; + while(nb--) { + cell_ptr = *block_ptr++; + i = cell_block_size; + while(i--) { + m_sorted_y[cell_ptr->y - m_min_y].start++; + ++cell_ptr; + } + } + i = m_num_cells & cell_block_mask; + if (i) { + cell_ptr = *block_ptr++; + } + while(i--) { + m_sorted_y[cell_ptr->y - m_min_y].start++; + ++cell_ptr; + } + unsigned start = 0; + for(i = 0; i < m_sorted_y.size(); i++) { + unsigned v = m_sorted_y[i].start; + m_sorted_y[i].start = start; + start += v; + } + block_ptr = m_cells; + nb = m_num_cells >> cell_block_shift; + while(nb--) { + cell_ptr = *block_ptr++; + i = cell_block_size; + while(i--) { + sorted_y& cur_y = m_sorted_y[cell_ptr->y - m_min_y]; + m_sorted_cells[cur_y.start + cur_y.num] = cell_ptr; + ++cur_y.num; + ++cell_ptr; + } + } + i = m_num_cells & cell_block_mask; + if (i) { + cell_ptr = *block_ptr++; + } + while(i--) { + sorted_y& cur_y = m_sorted_y[cell_ptr->y - m_min_y]; + m_sorted_cells[cur_y.start + cur_y.num] = cell_ptr; + ++cur_y.num; + ++cell_ptr; + } + for(i = 0; i < m_sorted_y.size(); i++) { + const sorted_y& cur_y = m_sorted_y[i]; + if(cur_y.num) { + qsort_cells(m_sorted_cells.data() + cur_y.start, cur_y.num); + } + } + m_sorted = true; +} +} diff --git a/third_party/agg23/agg_rasterizer_scanline_aa.h b/third_party/agg23/agg_rasterizer_scanline_aa.h new file mode 100644 index 0000000000..da1900d0dd --- /dev/null +++ b/third_party/agg23/agg_rasterizer_scanline_aa.h @@ -0,0 +1,472 @@ + +//---------------------------------------------------------------------------- +// 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 "../../core/include/fxge/fx_ge.h" +#include "agg_basics.h" +#include "agg_math.h" +#include "agg_array.h" +#include "agg_clip_liang_barsky.h" +#include "agg_render_scanlines.h" +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(FX_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 m_sorted_cells; + pod_array 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(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_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(FX_FLOAT x, FX_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 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; + unsigned alpha; + cover += cur_cell->cover; + while(--num_cells) { + cur_cell = *++cells; + if(cur_cell->x != x) { + break; + } + area += cur_cell->area; + cover += cur_cell->cover; + } + if(area) { + alpha = calculate_alpha((cover << (poly_base_shift + 1)) - area, no_smooth); + if(alpha) { + sl.add_cell(x, alpha); + } + x++; + } + if(num_cells && cur_cell->x > x) { + alpha = calculate_alpha(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 + void add_path(VertexSource& vs, unsigned path_id = 0) + { + FX_FLOAT x; + FX_FLOAT y; + unsigned cmd; + vs.rewind(path_id); + while(!is_stop(cmd = vs.vertex(&x, &y))) { + add_vertex(x, y, cmd); + } + } + template + void add_path_transformed(VertexSource& vs, const CFX_AffineMatrix* pMatrix, unsigned path_id = 0) + { + FX_FLOAT x; + FX_FLOAT y; + unsigned cmd; + vs.rewind(path_id); + while(!is_stop(cmd = vs.vertex(&x, &y))) { + if (pMatrix) { + pMatrix->Transform(x, 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: + 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; +}; +} +#endif diff --git a/third_party/agg23/agg_render_scanlines.h b/third_party/agg23/agg_render_scanlines.h new file mode 100644 index 0000000000..0dfd6d259f --- /dev/null +++ b/third_party/agg23/agg_render_scanlines.h @@ -0,0 +1,50 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_RENDER_SCANLINES_INCLUDED +#define AGG_RENDER_SCANLINES_INCLUDED +#include "agg_basics.h" +namespace agg +{ +template +void render_scanlines(Rasterizer& ras, Scanline& sl, Renderer& ren, bool no_smooth) +{ + if(ras.rewind_scanlines()) { + sl.reset(ras.min_x(), ras.max_x()); + ren.prepare(unsigned(ras.max_x() - ras.min_x() + 2)); + while(ras.sweep_scanline(sl, no_smooth)) { + ren.render(sl); + } + } +} +template +void render_all_paths(Rasterizer& ras, + Scanline& sl, + Renderer& r, + VertexSource& vs, + const ColorStorage& as, + const PathId& path_id, + unsigned num_paths) +{ + for(unsigned i = 0; i < num_paths; i++) { + ras.reset(); + ras.add_path(vs, path_id[i]); + r.color(as[i]); + render_scanlines(ras, sl, r); + } +} +} +#endif diff --git a/third_party/agg23/agg_renderer_base.h b/third_party/agg23/agg_renderer_base.h new file mode 100644 index 0000000000..bd1b203b9a --- /dev/null +++ b/third_party/agg23/agg_renderer_base.h @@ -0,0 +1,163 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// class renderer_base +// +//---------------------------------------------------------------------------- +#ifndef AGG_RENDERER_BASE_INCLUDED +#define AGG_RENDERER_BASE_INCLUDED +#include "agg_basics.h" +#include "agg_rendering_buffer.h" +namespace agg +{ +template class renderer_base +{ +public: + typedef PixelFormat pixfmt_type; + typedef typename pixfmt_type::color_type color_type; + typedef typename pixfmt_type::row_data row_data; + typedef typename pixfmt_type::span_data span_data; + renderer_base() : m_ren(0), m_clip_box(1, 1, 0, 0) {} + renderer_base(pixfmt_type& ren) : + m_ren(&ren), + m_clip_box(0, 0, ren.width() - 1, ren.height() - 1) + {} + void attach(pixfmt_type& ren) + { + m_ren = &ren; + m_clip_box = rect(0, 0, ren.width() - 1, ren.height() - 1); + } + const pixfmt_type& ren() const + { + return *m_ren; + } + pixfmt_type& ren() + { + return *m_ren; + } + unsigned width() const + { + return m_ren->width(); + } + unsigned height() const + { + return m_ren->height(); + } + void first_clip_box() {} + bool next_clip_box() + { + return false; + } + const rect& clip_box() const + { + return m_clip_box; + } + int xmin() const + { + return m_clip_box.x1; + } + int ymin() const + { + return m_clip_box.y1; + } + int xmax() const + { + return m_clip_box.x2; + } + int ymax() const + { + return m_clip_box.y2; + } + const rect& bounding_clip_box() const + { + return m_clip_box; + } + int bounding_xmin() const + { + return m_clip_box.x1; + } + int bounding_ymin() const + { + return m_clip_box.y1; + } + int bounding_xmax() const + { + return m_clip_box.x2; + } + int bounding_ymax() const + { + return m_clip_box.y2; + } + void blend_hline(int x1, int y, int x2, + const color_type& c, cover_type cover) + { + if(x1 > x2) { + int t = x2; + x2 = x1; + x1 = t; + } + if(y > ymax()) { + return; + } + if(y < ymin()) { + return; + } + if(x1 > xmax()) { + return; + } + if(x2 < xmin()) { + return; + } + if(x1 < xmin()) { + x1 = xmin(); + } + if(x2 > xmax()) { + x2 = xmax(); + } + m_ren->blend_hline(x1, y, x2 - x1 + 1, c, cover); + } + void blend_solid_hspan(int x, int y, int len, + const color_type& c, + const cover_type* covers) + { + if(y > ymax()) { + return; + } + if(y < ymin()) { + return; + } + if(x < xmin()) { + len -= xmin() - x; + if(len <= 0) { + return; + } + covers += xmin() - x; + x = xmin(); + } + if(x + len > xmax()) { + len = xmax() - x + 1; + if(len <= 0) { + return; + } + } + m_ren->blend_solid_hspan(x, y, len, c, covers); + } +private: + pixfmt_type* m_ren; + rect m_clip_box; +}; +} +#endif diff --git a/third_party/agg23/agg_renderer_scanline.h b/third_party/agg23/agg_renderer_scanline.h new file mode 100644 index 0000000000..62d104f7f2 --- /dev/null +++ b/third_party/agg23/agg_renderer_scanline.h @@ -0,0 +1,93 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_RENDERER_SCANLINE_INCLUDED +#define AGG_RENDERER_SCANLINE_INCLUDED +#include "agg_basics.h" +#include "agg_renderer_base.h" +#include "agg_render_scanlines.h" +namespace agg +{ +template class renderer_scanline_aa +{ +public: + typedef BaseRenderer base_ren_type; + typedef SpanGenerator span_gen_type; + renderer_scanline_aa() : m_ren(0), m_span_gen(0) {} + renderer_scanline_aa(base_ren_type& ren, span_gen_type& span_gen) : + m_ren(&ren), + m_span_gen(&span_gen) + {} + void attach(base_ren_type& ren, span_gen_type& span_gen) + { + m_ren = &ren; + m_span_gen = &span_gen; + } + void prepare(unsigned max_span_len) + { + m_span_gen->prepare(max_span_len); + } + template void render(const Scanline& sl) + { + int y = sl.y(); + m_ren->first_clip_box(); + do { + int xmin = m_ren->xmin(); + int xmax = m_ren->xmax(); + if(y >= m_ren->ymin() && y <= m_ren->ymax()) { + unsigned num_spans = sl.num_spans(); + typename Scanline::const_iterator span = sl.begin(); + for(;;) { + int x = span->x; + int len = span->len; + bool solid = false; + const typename Scanline::cover_type* covers = span->covers; + if(len < 0) { + solid = true; + len = -len; + } + if(x < xmin) { + len -= xmin - x; + if(!solid) { + covers += xmin - x; + } + x = xmin; + } + if(len > 0) { + if(x + len > xmax) { + len = xmax - x + 1; + } + if(len > 0) { + m_ren->blend_color_hspan_no_clip( + x, y, len, + m_span_gen->generate(x, y, len), + solid ? 0 : covers, + *covers); + } + } + if(--num_spans == 0) { + break; + } + ++span; + } + } + } while(m_ren->next_clip_box()); + } +private: + base_ren_type* m_ren; + SpanGenerator* m_span_gen; +}; +} +#endif diff --git a/third_party/agg23/agg_rendering_buffer.h b/third_party/agg23/agg_rendering_buffer.h new file mode 100644 index 0000000000..9c1c0c6899 --- /dev/null +++ b/third_party/agg23/agg_rendering_buffer.h @@ -0,0 +1,145 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// class rendering_buffer +// +//---------------------------------------------------------------------------- +#ifndef AGG_RENDERING_BUFFER_INCLUDED +#define AGG_RENDERING_BUFFER_INCLUDED +#include "agg_basics.h" +namespace agg +{ +class rendering_buffer +{ +public: + struct row_data { + int x1, x2; + const int8u* ptr; + row_data() {} + row_data(int x1_, int x2_, const int8u* ptr_) : + x1(x1_), x2(x2_), ptr(ptr_) {} + }; + struct span_data { + int x; + unsigned len; + int8u* ptr; + span_data() {} + span_data(int) : x(0), len(0), ptr(0) {} + span_data(int x_, unsigned len_, int8u* ptr_) : + x(x_), len(len_), ptr(ptr_) {} + }; + ~rendering_buffer() + { + FX_Free(m_rows); + } + rendering_buffer() : + m_buf(0), + m_rows(0), + m_width(0), + m_height(0), + m_stride(0), + m_max_height(0) + { + } + rendering_buffer(int8u* buf, unsigned width, unsigned height, int stride) : + m_buf(0), + m_rows(0), + m_width(0), + m_height(0), + m_stride(0), + m_max_height(0) + { + attach(buf, width, height, stride); + } + void attach(int8u* buf, unsigned width, unsigned height, int stride) + { + m_buf = buf; + m_width = width; + m_height = height; + m_stride = stride; + if(height > m_max_height) { + FX_Free(m_rows); + m_rows = FX_Alloc(int8u*, m_max_height = height); + } + int8u* row_ptr = m_buf; + if(stride < 0) { + row_ptr = m_buf - int(height - 1) * stride; + } + int8u** rows = m_rows; + while(height--) { + *rows++ = row_ptr; + row_ptr += stride; + } + } + int8u* buf() + { + return m_buf; + } + const int8u* buf() const + { + return m_buf; + } + unsigned width() const + { + return m_width; + } + unsigned height() const + { + return m_height; + } + int stride() const + { + return m_stride; + } + unsigned stride_abs() const + { + return (m_stride < 0) ? + unsigned(-m_stride) : + unsigned(m_stride); + } + int8u* row(unsigned y) + { + return m_rows[y]; + } + const int8u* row(unsigned y) const + { + return m_rows[y]; + } + int8u* next_row(void* p) + { + return (int8u*)p + m_stride; + } + const int8u* next_row(const void* p) const + { + return (int8u*)p + m_stride; + } + int8u const* const* rows() const + { + return m_rows; + } +private: + rendering_buffer(const rendering_buffer&); + const rendering_buffer& operator = (const rendering_buffer&); +private: + int8u* m_buf; + int8u** m_rows; + unsigned m_width; + unsigned m_height; + int m_stride; + unsigned m_max_height; +}; +} +#endif diff --git a/third_party/agg23/agg_scanline_u.h b/third_party/agg23/agg_scanline_u.h new file mode 100644 index 0000000000..2100115329 --- /dev/null +++ b/third_party/agg23/agg_scanline_u.h @@ -0,0 +1,150 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// 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 +{ +template class scanline_u +{ +public: + typedef scanline_u self_type; + typedef CoverT 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_u() + { + FX_Free(m_spans); + FX_Free(m_covers); + } + scanline_u() : + m_min_x(0), + m_max_len(0), + m_last_x(0x7FFFFFF0), + m_covers(0), + m_spans(0), + m_cur_span(0) + {} + void reset(int min_x, int max_x) + { + unsigned max_len = max_x - min_x + 2; + if(max_len > m_max_len) { + FX_Free(m_spans); + FX_Free(m_covers); + m_covers = FX_Alloc( cover_type , max_len); + m_spans = FX_Alloc( span , max_len); + m_max_len = max_len; + } + m_last_x = 0x7FFFFFF0; + m_min_x = min_x; + m_cur_span = m_spans; + } + 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 CoverT* covers) + { + x -= m_min_x; + FXSYS_memcpy(m_covers + x, covers, len * sizeof(CoverT)); + 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; + FXSYS_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; + } + int y() const + { + return m_y; + } + unsigned num_spans() const + { + return unsigned(m_cur_span - m_spans); + } + const_iterator begin() const + { + return m_spans + 1; + } + iterator begin() + { + return m_spans + 1; + } +private: + scanline_u(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* m_spans; + span* m_cur_span; +}; +typedef scanline_u scanline_u8; +} +#endif diff --git a/third_party/agg23/agg_shorten_path.h b/third_party/agg23/agg_shorten_path.h new file mode 100644 index 0000000000..d7eb4be018 --- /dev/null +++ b/third_party/agg23/agg_shorten_path.h @@ -0,0 +1,57 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_SHORTEN_PATH_INCLUDED +#define AGG_SHORTEN_PATH_INCLUDED +#include "agg_basics.h" +#include "agg_vertex_sequence.h" +namespace agg +{ +template +void shorten_path(VertexSequence& vs, FX_FLOAT s, unsigned closed = 0) +{ + typedef typename VertexSequence::value_type vertex_type; + if(s > 0 && vs.size() > 1) { + FX_FLOAT d; + int n = int(vs.size() - 2); + while(n) { + d = vs[n].dist; + if(d > s) { + break; + } + vs.remove_last(); + s -= d; + --n; + } + if(vs.size() < 2) { + vs.remove_all(); + } else { + n = vs.size() - 1; + vertex_type& prev = vs[n - 1]; + vertex_type& last = vs[n]; + d = (prev.dist - s) / prev.dist; + FX_FLOAT x = prev.x + (last.x - prev.x) * d; + FX_FLOAT y = prev.y + (last.y - prev.y) * d; + last.x = x; + last.y = y; + if(!prev(last)) { + vs.remove_last(); + } + vs.close(closed != 0); + } + } +} +} +#endif diff --git a/third_party/agg23/agg_vcgen_dash.cpp b/third_party/agg23/agg_vcgen_dash.cpp new file mode 100644 index 0000000000..43f8edf350 --- /dev/null +++ b/third_party/agg23/agg_vcgen_dash.cpp @@ -0,0 +1,176 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Line dash generator +// +//---------------------------------------------------------------------------- +#include "../../core/include/fxcrt/fx_basic.h" +#include "agg_vcgen_dash.h" +#include "agg_shorten_path.h" +namespace agg +{ +vcgen_dash::vcgen_dash() : + m_total_dash_len(0), + m_num_dashes(0), + m_dash_start(0), + m_shorten(0), + m_curr_dash_start(0), + m_curr_dash(0), + m_src_vertices(), + m_closed(0), + m_status(initial), + m_src_vertex(0) +{ +} +void vcgen_dash::remove_all_dashes() +{ + m_total_dash_len = 0; + m_num_dashes = 0; + m_curr_dash_start = 0; + m_curr_dash = 0; +} +void vcgen_dash::add_dash(FX_FLOAT dash_len, FX_FLOAT gap_len) +{ + if(m_num_dashes < max_dashes) { + m_total_dash_len += dash_len + gap_len; + m_dashes[m_num_dashes++] = dash_len; + m_dashes[m_num_dashes++] = gap_len; + } +} +void vcgen_dash::dash_start(FX_FLOAT ds) +{ + m_dash_start = ds; + calc_dash_start(FXSYS_fabs(ds)); +} +void vcgen_dash::calc_dash_start(FX_FLOAT ds) +{ + m_curr_dash = 0; + m_curr_dash_start = 0; + while(ds > 0) { + if(ds > m_dashes[m_curr_dash]) { + ds -= m_dashes[m_curr_dash]; + ++m_curr_dash; + m_curr_dash_start = 0; + if(m_curr_dash >= m_num_dashes) { + m_curr_dash = 0; + } + } else { + m_curr_dash_start = ds; + ds = 0; + } + } +} +void vcgen_dash::remove_all() +{ + m_status = initial; + m_src_vertices.remove_all(); + m_closed = 0; +} +void vcgen_dash::add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) +{ + m_status = initial; + if(is_move_to(cmd)) { + m_src_vertices.modify_last(vertex_dist(x, y)); + } else { + if(is_vertex(cmd)) { + m_src_vertices.add(vertex_dist(x, y)); + } else { + m_closed = get_close_flag(cmd); + } + } +} +void vcgen_dash::rewind(unsigned) +{ + if(m_status == initial) { + m_src_vertices.close(m_closed != 0); + shorten_path(m_src_vertices, m_shorten, m_closed); + } + m_status = ready; + m_src_vertex = 0; +} +unsigned vcgen_dash::vertex(FX_FLOAT* x, FX_FLOAT* y) +{ + unsigned cmd = path_cmd_move_to; + while(!is_stop(cmd)) { + switch(m_status) { + case initial: + rewind(0); + case ready: + if(m_num_dashes < 2 || m_src_vertices.size() < 2) { + cmd = path_cmd_stop; + break; + } + m_status = polyline; + m_src_vertex = 1; + m_v1 = &m_src_vertices[0]; + m_v2 = &m_src_vertices[1]; + m_curr_rest = m_v1->dist; + *x = m_v1->x; + *y = m_v1->y; + if(m_dash_start >= 0) { + calc_dash_start(m_dash_start); + } + return path_cmd_move_to; + case polyline: { + FX_FLOAT dash_rest = m_dashes[m_curr_dash] - m_curr_dash_start; + unsigned cmd = (m_curr_dash & 1) ? + path_cmd_move_to : + path_cmd_line_to; + if(m_curr_rest > dash_rest) { + m_curr_rest -= dash_rest; + ++m_curr_dash; + if(m_curr_dash >= m_num_dashes) { + m_curr_dash = 0; + } + m_curr_dash_start = 0; + *x = m_v2->x - (m_v2->x - m_v1->x) * m_curr_rest / m_v1->dist; + *y = m_v2->y - (m_v2->y - m_v1->y) * m_curr_rest / m_v1->dist; + } else { + m_curr_dash_start += m_curr_rest; + *x = m_v2->x; + *y = m_v2->y; + ++m_src_vertex; + m_v1 = m_v2; + m_curr_rest = m_v1->dist; + if(m_closed) { + if(m_src_vertex > m_src_vertices.size()) { + m_status = stop; + } else { + m_v2 = &m_src_vertices + [ + (m_src_vertex >= m_src_vertices.size()) ? 0 : + m_src_vertex + ]; + } + } else { + if(m_src_vertex >= m_src_vertices.size()) { + m_status = stop; + } else { + m_v2 = &m_src_vertices[m_src_vertex]; + } + } + } + return cmd; + } + break; + case stop: + cmd = path_cmd_stop; + break; + } + } + return path_cmd_stop; +} +} diff --git a/third_party/agg23/agg_vcgen_dash.h b/third_party/agg23/agg_vcgen_dash.h new file mode 100644 index 0000000000..9c3aa630c2 --- /dev/null +++ b/third_party/agg23/agg_vcgen_dash.h @@ -0,0 +1,75 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Line dash generator +// +//---------------------------------------------------------------------------- +#ifndef AGG_VCGEN_DASH_INCLUDED +#define AGG_VCGEN_DASH_INCLUDED +#include "agg_basics.h" +#include "agg_vertex_sequence.h" +namespace agg +{ +class vcgen_dash +{ + enum max_dashes_e { + max_dashes = 32 + }; + enum status_e { + initial, + ready, + polyline, + stop + }; +public: + typedef vertex_sequence vertex_storage; + vcgen_dash(); + void remove_all_dashes(); + void add_dash(FX_FLOAT dash_len, FX_FLOAT gap_len); + void dash_start(FX_FLOAT ds); + void shorten(FX_FLOAT s) + { + m_shorten = s; + } + double shorten() const + { + return m_shorten; + } + void remove_all(); + void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd); + void rewind(unsigned path_id); + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); +private: + vcgen_dash(const vcgen_dash&); + const vcgen_dash& operator = (const vcgen_dash&); + void calc_dash_start(FX_FLOAT ds); + FX_FLOAT m_dashes[max_dashes]; + FX_FLOAT m_total_dash_len; + unsigned m_num_dashes; + FX_FLOAT m_dash_start; + FX_FLOAT m_shorten; + FX_FLOAT m_curr_dash_start; + unsigned m_curr_dash; + FX_FLOAT m_curr_rest; + const vertex_dist* m_v1; + const vertex_dist* m_v2; + vertex_storage m_src_vertices; + unsigned m_closed; + status_e m_status; + unsigned m_src_vertex; +}; +} +#endif diff --git a/third_party/agg23/agg_vcgen_stroke.cpp b/third_party/agg23/agg_vcgen_stroke.cpp new file mode 100644 index 0000000000..9b8cb66fd9 --- /dev/null +++ b/third_party/agg23/agg_vcgen_stroke.cpp @@ -0,0 +1,214 @@ + +//---------------------------------------------------------------------------- +// XYQ: 2006-01-22 Copied from AGG project. +// TODO: This file uses intensive floating point operations, so it's NOT suitable +// for platforms like Symbian OS. We need to change to FIX format. +//---------------------------------------------------------------------------- +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// Stroke generator +// +//---------------------------------------------------------------------------- +#include "../../core/include/fxcrt/fx_basic.h" +#include "agg_vcgen_stroke.h" +namespace agg +{ + +vcgen_stroke::vcgen_stroke() : + m_src_vertices(), + m_out_vertices(), + m_width(0.5f), + m_miter_limit(4 * 1.0f), + m_inner_miter_limit(1.0f + 1.0f / 100), + m_approx_scale(1.0f), + m_line_cap(butt_cap), + m_line_join(miter_join), + m_inner_join(inner_miter), + m_closed(0), + m_status(initial), + m_src_vertex(0), + m_out_vertex(0) +{ +} +void vcgen_stroke::remove_all() +{ + m_src_vertices.remove_all(); + m_closed = 0; + m_status = initial; +} +void vcgen_stroke::add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) +{ + m_status = initial; + if(is_move_to(cmd)) { + m_src_vertices.modify_last(vertex_dist_cmd(x, y, cmd)); + } else { + if(is_vertex(cmd)) { + m_src_vertices.add(vertex_dist_cmd(x, y, cmd)); + } else { + m_closed = get_close_flag(cmd); + } + } +} +static inline void calc_butt_cap(FX_FLOAT* cap, + const vertex_dist& v0, + const vertex_dist& v1, + FX_FLOAT len, + FX_FLOAT width) +{ + FX_FLOAT dx = FXSYS_MulDiv(v1.y - v0.y, width, len); + FX_FLOAT dy = FXSYS_MulDiv(v1.x - v0.x, width, len); + cap[0] = v0.x - dx; + cap[1] = v0.y + dy; + cap[2] = v0.x + dx; + cap[3] = v0.y - dy; +} +void vcgen_stroke::rewind(unsigned) +{ + if(m_status == initial) { + m_src_vertices.close(m_closed != 0); + if(m_src_vertices.size() < 3) { + m_closed = 0; + } + } + m_status = ready; + m_src_vertex = 0; + m_out_vertex = 0; +} +unsigned vcgen_stroke::vertex(FX_FLOAT* x, FX_FLOAT* y) +{ + unsigned cmd = path_cmd_line_to; + line_join_e curj; + while(!is_stop(cmd)) { + switch(m_status) { + case initial: + rewind(0); + case ready: + if(m_src_vertices.size() < 2 + unsigned(m_closed != 0)) { + cmd = path_cmd_stop; + break; + } + m_status = m_closed ? outline1 : cap1; + cmd = path_cmd_move_to; + m_src_vertex = 0; + m_out_vertex = 0; + break; + case cap1: + stroke_calc_cap(m_out_vertices, + m_src_vertices[0], + m_src_vertices[1], + m_src_vertices[0].dist, + m_line_cap, + m_width, + m_approx_scale); + m_src_vertex = 1; + m_prev_status = outline1; + m_status = out_vertices; + m_out_vertex = 0; + break; + case cap2: + stroke_calc_cap(m_out_vertices, + m_src_vertices[m_src_vertices.size() - 1], + m_src_vertices[m_src_vertices.size() - 2], + m_src_vertices[m_src_vertices.size() - 2].dist, + m_line_cap, + m_width, + m_approx_scale); + m_prev_status = outline2; + m_status = out_vertices; + m_out_vertex = 0; + break; + case outline1: + if(m_closed) { + if(m_src_vertex >= m_src_vertices.size()) { + m_prev_status = close_first; + m_status = end_poly1; + break; + } + } else { + if(m_src_vertex >= m_src_vertices.size() - 1) { + m_status = cap2; + break; + } + } + curj = m_src_vertices[m_src_vertex].cmd & path_flags_jr ? miter_join_round : m_line_join; + stroke_calc_join(m_out_vertices, + m_src_vertices.prev(m_src_vertex), + m_src_vertices.curr(m_src_vertex), + m_src_vertices.next(m_src_vertex), + m_src_vertices.prev(m_src_vertex).dist, + m_src_vertices.curr(m_src_vertex).dist, + m_width, + curj, + m_inner_join, + m_miter_limit, + m_inner_miter_limit, + m_approx_scale); + ++m_src_vertex; + m_prev_status = m_status; + m_status = out_vertices; + m_out_vertex = 0; + break; + case close_first: + m_status = outline2; + cmd = path_cmd_move_to; + case outline2: + if(m_src_vertex <= unsigned(m_closed == 0)) { + m_status = end_poly2; + m_prev_status = stop; + break; + } + --m_src_vertex; + curj = m_src_vertices[m_src_vertex].cmd & path_flags_jr ? miter_join_round : m_line_join; + stroke_calc_join(m_out_vertices, + m_src_vertices.next(m_src_vertex), + m_src_vertices.curr(m_src_vertex), + m_src_vertices.prev(m_src_vertex), + m_src_vertices.curr(m_src_vertex).dist, + m_src_vertices.prev(m_src_vertex).dist, + m_width, + curj, + m_inner_join, + m_miter_limit, + m_inner_miter_limit, + m_approx_scale); + m_prev_status = m_status; + m_status = out_vertices; + m_out_vertex = 0; + break; + case out_vertices: + if(m_out_vertex >= m_out_vertices.size()) { + m_status = m_prev_status; + } else { + const point_type& c = m_out_vertices[m_out_vertex++]; + *x = c.x; + *y = c.y; + return cmd; + } + break; + case end_poly1: + m_status = m_prev_status; + return path_cmd_end_poly | path_flags_close | path_flags_ccw; + case end_poly2: + m_status = m_prev_status; + return path_cmd_end_poly | path_flags_close | path_flags_cw; + case stop: + cmd = path_cmd_stop; + break; + } + } + return cmd; +} +} diff --git a/third_party/agg23/agg_vcgen_stroke.h b/third_party/agg23/agg_vcgen_stroke.h new file mode 100644 index 0000000000..84fadd6ed8 --- /dev/null +++ b/third_party/agg23/agg_vcgen_stroke.h @@ -0,0 +1,120 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +#ifndef AGG_VCGEN_STROKE_INCLUDED +#define AGG_VCGEN_STROKE_INCLUDED +#include "agg_math_stroke.h" +namespace agg +{ +class vcgen_stroke +{ + enum status_e { + initial, + ready, + cap1, + cap2, + outline1, + close_first, + outline2, + out_vertices, + end_poly1, + end_poly2, + stop + }; +public: + typedef vertex_sequence vertex_storage; + typedef pod_deque coord_storage; + vcgen_stroke(); + void line_cap(line_cap_e lc) + { + m_line_cap = lc; + } + void line_join(line_join_e lj) + { + m_line_join = lj; + } + void inner_join(inner_join_e ij) + { + m_inner_join = ij; + } + line_cap_e line_cap() const + { + return m_line_cap; + } + line_join_e line_join() const + { + return m_line_join; + } + inner_join_e inner_join() const + { + return m_inner_join; + } + void width(FX_FLOAT w) + { + m_width = w / 2; + } + void miter_limit(FX_FLOAT ml) + { + m_miter_limit = ml; + } + void miter_limit_theta(FX_FLOAT t); + void inner_miter_limit(FX_FLOAT ml) + { + m_inner_miter_limit = ml; + } + void approximation_scale(FX_FLOAT as) + { + m_approx_scale = as; + } + FX_FLOAT width() const + { + return m_width * 2; + } + FX_FLOAT miter_limit() const + { + return m_miter_limit; + } + FX_FLOAT inner_miter_limit() const + { + return m_inner_miter_limit; + } + FX_FLOAT approximation_scale() const + { + return m_approx_scale; + } + void remove_all(); + void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd); + void rewind(unsigned path_id); + unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); +private: + vcgen_stroke(const vcgen_stroke&); + const vcgen_stroke& operator = (const vcgen_stroke&); + vertex_storage m_src_vertices; + coord_storage m_out_vertices; + FX_FLOAT m_width; + FX_FLOAT m_miter_limit; + FX_FLOAT m_inner_miter_limit; + FX_FLOAT m_approx_scale; + line_cap_e m_line_cap; + line_join_e m_line_join; + inner_join_e m_inner_join; + unsigned m_closed; + status_e m_status; + status_e m_prev_status; + unsigned m_src_vertex; + unsigned m_out_vertex; +}; +} +#endif diff --git a/third_party/agg23/agg_vertex_sequence.h b/third_party/agg23/agg_vertex_sequence.h new file mode 100644 index 0000000000..6600bf2085 --- /dev/null +++ b/third_party/agg23/agg_vertex_sequence.h @@ -0,0 +1,100 @@ + +//---------------------------------------------------------------------------- +// 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. +// +//---------------------------------------------------------------------------- +// Contact: mcseem@antigrain.com +// mcseemagg@yahoo.com +// http://www.antigrain.com +//---------------------------------------------------------------------------- +// +// vertex_sequence container and vertex_dist struct +// +//---------------------------------------------------------------------------- +#ifndef AGG_VERTEX_SEQUENCE_INCLUDED +#define AGG_VERTEX_SEQUENCE_INCLUDED +#include "agg_basics.h" +#include "agg_array.h" +#include "agg_math.h" +namespace agg +{ +template +class vertex_sequence : public pod_deque +{ +public: + typedef pod_deque base_type; + void add(const T& val); + void modify_last(const T& val); + void close(bool remove_flag); +}; +template +void vertex_sequence::add(const T& val) +{ + if(base_type::size() > 1) { + if(!(*this)[base_type::size() - 2]((*this)[base_type::size() - 1])) { + base_type::remove_last(); + } + } + base_type::add(val); +} +template +void vertex_sequence::modify_last(const T& val) +{ + base_type::remove_last(); + add(val); +} +template +void vertex_sequence::close(bool closed) +{ + while(base_type::size() > 1) { + if((*this)[base_type::size() - 2]((*this)[base_type::size() - 1])) { + break; + } + T t = (*this)[base_type::size() - 1]; + base_type::remove_last(); + modify_last(t); + } + if(closed) { + while(base_type::size() > 1) { + if((*this)[base_type::size() - 1]((*this)[0])) { + break; + } + base_type::remove_last(); + } + } +} +const FX_FLOAT vertex_dist_epsilon = 1e-14f; +struct vertex_dist { + FX_FLOAT x; + FX_FLOAT y; + FX_FLOAT dist; + vertex_dist() {} + vertex_dist(FX_FLOAT x_, FX_FLOAT y_) : + x(x_), + y(y_), + dist(0) + { + } + bool operator () (const vertex_dist& val) + { + bool ret = (dist = calc_distance(x, y, val.x, val.y)) > vertex_dist_epsilon; + return ret; + } +}; +struct vertex_dist_cmd : public vertex_dist { + unsigned cmd; + vertex_dist_cmd() {} + vertex_dist_cmd(FX_FLOAT x_, FX_FLOAT y_, unsigned cmd_) : + vertex_dist(x_, y_), + cmd(cmd_) + { + } +}; +} +#endif -- cgit v1.2.3