From 05df075154a832fcb476e1dfcfb865722d0ea898 Mon Sep 17 00:00:00 2001 From: Dan Sinclair Date: Tue, 14 Mar 2017 14:43:42 -0400 Subject: Replace FX_FLOAT with underlying float type. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I158b7d80b0ec28b742a9f2d5a96f3dde7fb3ab56 Reviewed-on: https://pdfium-review.googlesource.com/3031 Commit-Queue: dsinclair Reviewed-by: Tom Sepez Reviewed-by: Nicolás Peña --- third_party/agg23/0001-gcc-warning.patch | 2 +- third_party/agg23/0002-ubsan-error-fixes.patch | 14 ++--- third_party/agg23/agg_basics.h | 14 ++--- third_party/agg23/agg_clip_liang_barsky.h | 42 ++++++------- third_party/agg23/agg_conv_adaptor_vcgen.h | 12 ++-- third_party/agg23/agg_conv_dash.h | 6 +- third_party/agg23/agg_conv_stroke.h | 22 +++---- third_party/agg23/agg_curves.cpp | 58 +++++++++--------- third_party/agg23/agg_curves.h | 82 +++++++++++++------------- third_party/agg23/agg_math.h | 36 +++++------ third_party/agg23/agg_math_stroke.h | 76 ++++++++++++------------ third_party/agg23/agg_path_storage.cpp | 18 +++--- third_party/agg23/agg_path_storage.h | 48 +++++++-------- third_party/agg23/agg_rasterizer_scanline_aa.h | 14 ++--- third_party/agg23/agg_shorten_path.h | 8 +-- third_party/agg23/agg_vcgen_dash.cpp | 12 ++-- third_party/agg23/agg_vcgen_dash.h | 24 ++++---- third_party/agg23/agg_vcgen_stroke.cpp | 14 ++--- third_party/agg23/agg_vcgen_stroke.h | 30 +++++----- third_party/agg23/agg_vertex_sequence.h | 12 ++-- 20 files changed, 272 insertions(+), 272 deletions(-) (limited to 'third_party') diff --git a/third_party/agg23/0001-gcc-warning.patch b/third_party/agg23/0001-gcc-warning.patch index 759696ef03..3bdce6578e 100644 --- a/third_party/agg23/0001-gcc-warning.patch +++ b/third_party/agg23/0001-gcc-warning.patch @@ -4,7 +4,7 @@ index dc13851..7f21bac 100644 +++ b/third_party/agg23/agg_path_storage.h @@ -38,9 +38,9 @@ public: } - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + unsigned vertex(float* x, float* y) { - return (m_vertex_idx < m_path->total_vertices()) ? - m_path->vertex(m_vertex_idx++, x, y) : diff --git a/third_party/agg23/0002-ubsan-error-fixes.patch b/third_party/agg23/0002-ubsan-error-fixes.patch index 00ced0071c..58b17dc19c 100644 --- a/third_party/agg23/0002-ubsan-error-fixes.patch +++ b/third_party/agg23/0002-ubsan-error-fixes.patch @@ -13,21 +13,21 @@ index db6ca97..5b1261f 100644 @@ -36,8 +37,18 @@ inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2, T* x, T* y) { - const FX_FLOAT nearzero = 1e-30f; -- FX_FLOAT deltax = (FX_FLOAT)(x2 - x1); -- FX_FLOAT deltay = (FX_FLOAT)(y2 - y1); + const float nearzero = 1e-30f; +- float deltax = (float)(x2 - x1); +- float deltay = (float)(y2 - y1); + -+ pdfium::base::CheckedNumeric width = x2; ++ pdfium::base::CheckedNumeric width = x2; + width -= x1; + if (!width.IsValid()) + return 0; -+ pdfium::base::CheckedNumeric height = y2; ++ pdfium::base::CheckedNumeric height = y2; + height -= y1; + if (!height.IsValid()) + return 0; + -+ FX_FLOAT deltax = width.ValueOrDefault(0); -+ FX_FLOAT deltay = height.ValueOrDefault(0); ++ float deltax = width.ValueOrDefault(0); ++ float deltay = height.ValueOrDefault(0); unsigned np = 0; if(deltax == 0) { deltax = (x1 > clip_box.x1) ? -nearzero : nearzero; diff --git a/third_party/agg23/agg_basics.h b/third_party/agg23/agg_basics.h index 52a658ec96..fc155561e0 100644 --- a/third_party/agg23/agg_basics.h +++ b/third_party/agg23/agg_basics.h @@ -41,7 +41,7 @@ #endif #define AGG_INLINE inline -#include "core/fxcrt/fx_system.h" // For FX_FLOAT +#include "core/fxcrt/fx_system.h" namespace agg { @@ -143,7 +143,7 @@ inline Rect unite_rectangles(const Rect& r1, const Rect& r2) return r; } typedef rect_base rect; -typedef rect_base rect_d; +typedef rect_base rect_d; enum path_commands_e { path_cmd_stop = 0, path_cmd_move_to = 1, @@ -261,10 +261,10 @@ inline unsigned set_orientation(unsigned c, unsigned o) return clear_orientation(c) | o; } struct point_type { - FX_FLOAT x, y; + float x, y; unsigned flag; point_type() {} - point_type(FX_FLOAT x_, FX_FLOAT y_, unsigned flag_ = 0) : x(x_), y(y_), flag(flag_) {} + point_type(float x_, float y_, unsigned flag_ = 0) : x(x_), y(y_), flag(flag_) {} }; struct point_type_flag : public point_type { unsigned flag; @@ -272,13 +272,13 @@ struct point_type_flag : public point_type { { flag = 0; } - point_type_flag(FX_FLOAT x_, FX_FLOAT y_, unsigned flag_ = 0) : point_type(x_, y_), flag(flag_) {} + point_type_flag(float x_, float y_, unsigned flag_ = 0) : point_type(x_, y_), flag(flag_) {} }; struct vertex_type { - FX_FLOAT x, y; + float x, y; unsigned cmd; vertex_type() {} - vertex_type(FX_FLOAT x_, FX_FLOAT y_, unsigned cmd_) : + vertex_type(float x_, float y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {} }; } diff --git a/third_party/agg23/agg_clip_liang_barsky.h b/third_party/agg23/agg_clip_liang_barsky.h index 5b1261f004..31b35fe96e 100644 --- a/third_party/agg23/agg_clip_liang_barsky.h +++ b/third_party/agg23/agg_clip_liang_barsky.h @@ -36,45 +36,45 @@ 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; + const float nearzero = 1e-30f; - pdfium::base::CheckedNumeric width = x2; + pdfium::base::CheckedNumeric width = x2; width -= x1; if (!width.IsValid()) return 0; - pdfium::base::CheckedNumeric height = y2; + pdfium::base::CheckedNumeric height = y2; height -= y1; if (!height.IsValid()) return 0; - FX_FLOAT deltax = width.ValueOrDefault(0); - FX_FLOAT deltay = height.ValueOrDefault(0); + float deltax = width.ValueOrDefault(0); + float deltay = height.ValueOrDefault(0); unsigned np = 0; if(deltax == 0) { deltax = (x1 > clip_box.x1) ? -nearzero : nearzero; } - FX_FLOAT xin, xout; + float xin, xout; if(deltax > 0) { - xin = (FX_FLOAT)clip_box.x1; - xout = (FX_FLOAT)clip_box.x2; + xin = (float)clip_box.x1; + xout = (float)clip_box.x2; } else { - xin = (FX_FLOAT)clip_box.x2; - xout = (FX_FLOAT)clip_box.x1; + xin = (float)clip_box.x2; + xout = (float)clip_box.x1; } - FX_FLOAT tinx = (xin - x1) / deltax; + float tinx = (xin - x1) / deltax; if(deltay == 0) { deltay = (y1 > clip_box.y1) ? -nearzero : nearzero; } - FX_FLOAT yin, yout; + float yin, yout; if(deltay > 0) { - yin = (FX_FLOAT)clip_box.y1; - yout = (FX_FLOAT)clip_box.y2; + yin = (float)clip_box.y1; + yout = (float)clip_box.y2; } else { - yin = (FX_FLOAT)clip_box.y2; - yout = (FX_FLOAT)clip_box.y1; + yin = (float)clip_box.y2; + yout = (float)clip_box.y1; } - FX_FLOAT tiny = (yin - y1) / deltay; - FX_FLOAT tin1, tin2; + float tiny = (yin - y1) / deltay; + float tin1, tin2; if (tinx < tiny) { tin1 = tinx; tin2 = tiny; @@ -89,9 +89,9 @@ inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2, ++np; } if(tin2 <= 1.0f) { - FX_FLOAT toutx = (xout - x1) / deltax; - FX_FLOAT touty = (yout - y1) / deltay; - FX_FLOAT tout1 = (toutx < touty) ? toutx : touty; + float toutx = (xout - x1) / deltax; + float touty = (yout - y1) / deltay; + float tout1 = (toutx < touty) ? toutx : touty; if (tin2 > 0 || tout1 > 0) { if(tin2 <= tout1) { if(tin2 > 0) { diff --git a/third_party/agg23/agg_conv_adaptor_vcgen.h b/third_party/agg23/agg_conv_adaptor_vcgen.h index 0d8d6ff99e..be4dc2d609 100644 --- a/third_party/agg23/agg_conv_adaptor_vcgen.h +++ b/third_party/agg23/agg_conv_adaptor_vcgen.h @@ -20,10 +20,10 @@ namespace agg { struct null_markers { void remove_all() {} - void add_vertex(FX_FLOAT, FX_FLOAT, unsigned) {} + void add_vertex(float, float, unsigned) {} void prepare_src() {} void rewind(unsigned) {} - unsigned vertex(FX_FLOAT*, FX_FLOAT*) + unsigned vertex(float*, float*) { return path_cmd_stop; } @@ -67,7 +67,7 @@ public: m_source->rewind(path_id); m_status = initial; } - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); + unsigned vertex(float* x, float* y); private: conv_adaptor_vcgen(const conv_adaptor_vcgen&); const conv_adaptor_vcgen& @@ -77,11 +77,11 @@ private: Markers m_markers; status m_status; unsigned m_last_cmd; - FX_FLOAT m_start_x; - FX_FLOAT m_start_y; + float m_start_x; + float m_start_y; }; template -unsigned conv_adaptor_vcgen::vertex(FX_FLOAT* x, FX_FLOAT* y) +unsigned conv_adaptor_vcgen::vertex(float* x, float* y) { unsigned cmd = path_cmd_stop; bool done = false; diff --git a/third_party/agg23/agg_conv_dash.h b/third_party/agg23/agg_conv_dash.h index 63b2019dde..f87eccc3b1 100644 --- a/third_party/agg23/agg_conv_dash.h +++ b/third_party/agg23/agg_conv_dash.h @@ -36,15 +36,15 @@ struct conv_dash : public conv_adaptor_vcgen { base_type::generator().remove_all_dashes(); } - void add_dash(FX_FLOAT dash_len, FX_FLOAT gap_len) + void add_dash(float dash_len, float gap_len) { base_type::generator().add_dash(dash_len, gap_len); } - void dash_start(FX_FLOAT ds) + void dash_start(float ds) { base_type::generator().dash_start(ds); } - void shorten(FX_FLOAT s) + void shorten(float s) { base_type::generator().shorten(s); } diff --git a/third_party/agg23/agg_conv_stroke.h b/third_party/agg23/agg_conv_stroke.h index 5a36bd73bb..82268ddec6 100644 --- a/third_party/agg23/agg_conv_stroke.h +++ b/third_party/agg23/agg_conv_stroke.h @@ -57,47 +57,47 @@ struct conv_stroke : { return base_type::generator().inner_join(); } - void width(FX_FLOAT w) + void width(float w) { base_type::generator().width(w); } - void miter_limit(FX_FLOAT ml) + void miter_limit(float ml) { base_type::generator().miter_limit(ml); } - void miter_limit_theta(FX_FLOAT t) + void miter_limit_theta(float t) { base_type::generator().miter_limit_theta(t); } - void inner_miter_limit(FX_FLOAT ml) + void inner_miter_limit(float ml) { base_type::generator().inner_miter_limit(ml); } - void approximation_scale(FX_FLOAT as) + void approximation_scale(float as) { base_type::generator().approximation_scale(as); } - FX_FLOAT width() const + float width() const { return base_type::generator().width(); } - FX_FLOAT miter_limit() const + float miter_limit() const { return base_type::generator().miter_limit(); } - FX_FLOAT inner_miter_limit() const + float inner_miter_limit() const { return base_type::generator().inner_miter_limit(); } - FX_FLOAT approximation_scale() const + float approximation_scale() const { return base_type::generator().approximation_scale(); } - void shorten(FX_FLOAT s) + void shorten(float s) { base_type::generator().shorten(s); } - FX_FLOAT shorten() const + float shorten() const { return base_type::generator().shorten(); } diff --git a/third_party/agg23/agg_curves.cpp b/third_party/agg23/agg_curves.cpp index b86cf630c3..4bfe457817 100644 --- a/third_party/agg23/agg_curves.cpp +++ b/third_party/agg23/agg_curves.cpp @@ -25,12 +25,12 @@ namespace agg { -const FX_FLOAT curve_collinearity_epsilon = 1e-30f; +const 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) +void curve4_div::init(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { m_points.remove_all(); m_distance_tolerance_square = 1.0f / 4; @@ -38,31 +38,31 @@ void curve4_div::init(FX_FLOAT x1, FX_FLOAT y1, 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, +void curve4_div::recursive_bezier(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, 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(((x2 - x4) * dy) - ((y2 - y4) * dx)); - FX_FLOAT d3 = FXSYS_fabs(((x3 - x4) * dy) - ((y3 - y4) * dx)); + float x12 = (x1 + x2) / 2; + float y12 = (y1 + y2) / 2; + float x23 = (x2 + x3) / 2; + float y23 = (y2 + y3) / 2; + float x34 = (x3 + x4) / 2; + float y34 = (y3 + y4) / 2; + float x123 = (x12 + x23) / 2; + float y123 = (y12 + y23) / 2; + float x234 = (x23 + x34) / 2; + float y234 = (y23 + y34) / 2; + float x1234 = (x123 + x234) / 2; + float y1234 = (y123 + y234) / 2; + float dx = x4 - x1; + float dy = y4 - y1; + float d2 = FXSYS_fabs(((x2 - x4) * dy) - ((y2 - y4) * dx)); + float d3 = FXSYS_fabs(((x3 - x4) * dy) - ((y3 - y4) * dx)); switch((int(d2 > curve_collinearity_epsilon) << 1) + int(d3 > curve_collinearity_epsilon)) { case 0: @@ -99,10 +99,10 @@ void curve4_div::recursive_bezier(FX_FLOAT x1, FX_FLOAT y1, 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) +void curve4_div::bezier(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { m_points.add(point_type(x1, y1)); recursive_bezier(x1, y1, x2, y2, x3, y3, x4, y4, 0); diff --git a/third_party/agg23/agg_curves.h b/third_party/agg23/agg_curves.h index 495f7a6a8f..488db4a1ff 100644 --- a/third_party/agg23/agg_curves.h +++ b/third_party/agg23/agg_curves.h @@ -20,12 +20,12 @@ namespace agg { struct curve4_points { - FX_FLOAT cp[8]; + 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) + curve4_points(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { cp[0] = x1; cp[1] = y1; @@ -36,10 +36,10 @@ struct curve4_points { 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) + void init(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { cp[0] = x1; cp[1] = y1; @@ -50,11 +50,11 @@ struct curve4_points { cp[6] = x4; cp[7] = y4; } - FX_FLOAT operator [] (unsigned i) const + float operator [] (unsigned i) const { return cp[i]; } - FX_FLOAT& operator [] (unsigned i) + float& operator [] (unsigned i) { return cp[i]; } @@ -65,10 +65,10 @@ 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) : + curve4_div(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) : m_count(0) { init(x1, y1, x2, y2, x3, y3, x4, y4); @@ -83,10 +83,10 @@ public: 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(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, 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]); @@ -95,7 +95,7 @@ public: { m_count = 0; } - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + unsigned vertex(float* x, float* y) { if(m_count >= m_points.size()) { return path_cmd_stop; @@ -105,7 +105,7 @@ public: *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) + unsigned vertex_flag(float* x, float* y, int& flag) { if(m_count >= m_points.size()) { return path_cmd_stop; @@ -121,17 +121,17 @@ public: 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, + void bezier(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4); + void recursive_bezier(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4, unsigned level); - FX_FLOAT m_distance_tolerance_square; - FX_FLOAT m_distance_tolerance_manhattan; + float m_distance_tolerance_square; + float m_distance_tolerance_manhattan; unsigned m_count; pod_deque m_points; }; @@ -139,10 +139,10 @@ 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) + curve4(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { init(x1, y1, x2, y2, x3, y3, x4, y4); } @@ -154,10 +154,10 @@ public: { 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) + void init(float x1, float y1, + float x2, float y2, + float x3, float y3, + float x4, float y4) { m_curve_div.init(x1, y1, x2, y2, x3, y3, x4, y4); } @@ -169,11 +169,11 @@ public: { m_curve_div.rewind(path_id); } - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + unsigned vertex(float* x, float* y) { return m_curve_div.vertex(x, y); } - unsigned vertex_curve_flag(FX_FLOAT* x, FX_FLOAT* y, int& flag) + unsigned vertex_curve_flag(float* x, float* y, int& flag) { return m_curve_div.vertex_flag(x, y, flag); } diff --git a/third_party/agg23/agg_math.h b/third_party/agg23/agg_math.h index e003297dff..6c03bab929 100644 --- a/third_party/agg23/agg_math.h +++ b/third_party/agg23/agg_math.h @@ -21,37 +21,37 @@ #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) +const float intersection_epsilon = 1.0e-30f; +AGG_INLINE float calc_point_location(float x1, float y1, + float x2, float y2, + float x, float y) { return ((x - x2) * (y2 - y1)) - ((y - y2) * (x2 - x1)); } -AGG_INLINE FX_FLOAT calc_distance(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2) +AGG_INLINE float calc_distance(float x1, float y1, float x2, float y2) { - FX_FLOAT dx = x2 - x1; - FX_FLOAT dy = y2 - y1; + float dx = x2 - x1; + 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) +AGG_INLINE float calc_line_point_distance(float x1, float y1, + float x2, float y2, + float x, float y) { - FX_FLOAT dx = x2 - x1; - FX_FLOAT dy = y2 - y1; - FX_FLOAT d = FXSYS_sqrt2(dx, dy); + float dx = x2 - x1; + float dy = y2 - y1; + float d = FXSYS_sqrt2(dx, dy); if(d < intersection_epsilon) { return calc_distance(x1, y1, x, y); } return ((x - x2) * dy / d) - ((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) +AGG_INLINE bool calc_intersection(float ax, float ay, float bx, float by, + float cx, float cy, float dx, float dy, + float* x, float* y) { - FX_FLOAT num = ((ay - cy) * (dx - cx)) - ((ax - cx) * (dy - cy)); - FX_FLOAT den = ((bx - ax) * (dy - cy)) - ((by - ay) * (dx - cx)); + float num = ((ay - cy) * (dx - cx)) - ((ax - cx) * (dy - cy)); + float den = ((bx - ax) * (dy - cy)) - ((by - ay) * (dx - cx)); if (FXSYS_fabs(den) < intersection_epsilon) { return false; } diff --git a/third_party/agg23/agg_math_stroke.h b/third_party/agg23/agg_math_stroke.h index 2b06b1bfda..90c1153cc5 100644 --- a/third_party/agg23/agg_math_stroke.h +++ b/third_party/agg23/agg_math_stroke.h @@ -41,19 +41,19 @@ enum inner_join_e { inner_jag, inner_round }; -const FX_FLOAT stroke_theta = 1.0f / 1000.0f; +const 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) + float x, float y, + float dx1, float dy1, + float dx2, float dy2, + float width, + 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; + float a1 = FXSYS_atan2(dy1, dx1); + float a2 = FXSYS_atan2(dy2, dx2); + float da = a1 - a2; bool ccw = da > 0 && da < FX_PI; if(width < 0) { width = -width; @@ -92,31 +92,31 @@ 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, + float dx1, float dy1, + float dx2, float dy2, + float width, line_join_e line_join, - FX_FLOAT miter_limit, - FX_FLOAT approximation_scale) + float miter_limit, + float approximation_scale) { typedef typename VertexConsumer::value_type coord_type; - FX_FLOAT xi = v1.x; - FX_FLOAT yi = v1.y; + float xi = v1.x; + 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 = width * miter_limit; + float d1 = calc_distance(v1.x, v1.y, xi, yi); + float lim = 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; + float x2 = v1.x + dx1; + float y2 = v1.y - dy1; if ((((x2 - v0.x) * dy1) - ((v0.y - y2) * dx1) < 0) != (((x2 - v2.x) * dy1) - ((v2.y - y2) * dx1) < 0)) { out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1)); @@ -147,17 +147,17 @@ template void stroke_calc_cap(VertexConsumer& out_vertices, const vertex_dist& v0, const vertex_dist& v1, - FX_FLOAT len, + float len, line_cap_e line_cap, - FX_FLOAT width, - FX_FLOAT approximation_scale) + float width, + float approximation_scale) { typedef typename VertexConsumer::value_type coord_type; out_vertices.remove_all(); - FX_FLOAT dx1 = (v1.y - v0.y) / len; - FX_FLOAT dy1 = (v1.x - v0.x) / len; - FX_FLOAT dx2 = 0; - FX_FLOAT dy2 = 0; + float dx1 = (v1.y - v0.y) / len; + float dy1 = (v1.x - v0.x) / len; + float dx2 = 0; + float dy2 = 0; dx1 = dx1 * width; dy1 = dy1 * width; if(line_cap != round_cap) { @@ -168,9 +168,9 @@ void stroke_calc_cap(VertexConsumer& out_vertices, 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 = + float a1 = FXSYS_atan2(dy1, -dx1); + float a2 = a1 + FX_PI; + float da = FXSYS_acos(width / (width + ((1.0f / 8) / approximation_scale))) * 2; out_vertices.add(coord_type(v0.x - dx1, v0.y + dy1)); @@ -189,17 +189,17 @@ 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, + float len1, + float len2, + 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) + float miter_limit, + float inner_miter_limit, + float approximation_scale) { typedef typename VertexConsumer::value_type coord_type; - FX_FLOAT dx1, dy1, dx2, dy2; + float dx1, dy1, dx2, dy2; dx1 = width * (v1.y - v0.y) / len1; dy1 = width * (v1.x - v0.x) / len1; dx2 = width * (v2.y - v1.y) / len2; @@ -221,7 +221,7 @@ void stroke_calc_join(VertexConsumer& out_vertices, break; case inner_jag: case inner_round: { - FX_FLOAT d = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2); + 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, diff --git a/third_party/agg23/agg_path_storage.cpp b/third_party/agg23/agg_path_storage.cpp index 968746738a..747777d28e 100644 --- a/third_party/agg23/agg_path_storage.cpp +++ b/third_party/agg23/agg_path_storage.cpp @@ -32,7 +32,7 @@ namespace agg path_storage::~path_storage() { if(m_total_blocks) { - FX_FLOAT** coord_blk = m_coord_blocks + m_total_blocks - 1; + float** coord_blk = m_coord_blocks + m_total_blocks - 1; while(m_total_blocks--) { FX_Free(*coord_blk); --coord_blk; @@ -52,14 +52,14 @@ path_storage::path_storage() : 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); + float** new_coords = + FX_Alloc2D(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*)); + m_max_blocks * sizeof(float*)); FXSYS_memcpy(new_cmds, m_cmd_blocks, m_max_blocks * sizeof(unsigned char*)); @@ -70,9 +70,9 @@ void path_storage::allocate_block(unsigned nb) m_max_blocks += block_pool; } m_coord_blocks[nb] = - FX_Alloc( FX_FLOAT, block_size * 2 + + FX_Alloc( float, block_size * 2 + block_size / - (sizeof(FX_FLOAT) / sizeof(unsigned char))); + (sizeof(float) / sizeof(unsigned char))); m_cmd_blocks[nb] = (unsigned char*)(m_coord_blocks[nb] + block_size * 2); m_total_blocks++; @@ -81,9 +81,9 @@ 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) +void path_storage::curve4(float x_ctrl1, float y_ctrl1, + float x_ctrl2, float y_ctrl2, + float x_to, float y_to) { add_vertex(x_ctrl1, y_ctrl1, path_cmd_curve4); add_vertex(x_ctrl2, y_ctrl2, path_cmd_curve4); diff --git a/third_party/agg23/agg_path_storage.h b/third_party/agg23/agg_path_storage.h index 7f21bacd09..17e82d73e4 100644 --- a/third_party/agg23/agg_path_storage.h +++ b/third_party/agg23/agg_path_storage.h @@ -36,7 +36,7 @@ public: { m_vertex_idx = path_id; } - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y) + unsigned vertex(float* x, float* y) { return (m_vertex_idx < m_path->total_vertices()) ? m_path->vertex(m_vertex_idx++, x, y) @@ -48,19 +48,19 @@ public: }; ~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); + unsigned last_vertex(float* x, float* y) const; + unsigned prev_vertex(float* x, float* y) const; + void move_to(float x, float y); + void line_to(float x, float y); + void curve4(float x_ctrl1, float y_ctrl1, + float x_ctrl2, float y_ctrl2, + float x_to, float y_to); template void add_path(VertexSource& vs, unsigned path_id = 0, bool solid_path = true) { - FX_FLOAT x, y; + float x, y; unsigned cmd; vs.rewind(path_id); while(!is_stop(cmd = vs.vertex(&x, &y))) { @@ -75,7 +75,7 @@ public: unsigned path_id = 0, bool solid_path = true) { - FX_FLOAT x, y; + float x, y; unsigned cmd; int flag; vs.rewind(path_id); @@ -90,10 +90,10 @@ public: { return m_total_vertices; } - unsigned vertex(unsigned idx, FX_FLOAT* x, FX_FLOAT* y) const + unsigned vertex(unsigned idx, float* x, float* y) const { unsigned nb = idx >> block_shift; - const FX_FLOAT* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1); + const float* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1); *x = *pv++; *y = *pv; return m_cmd_blocks[nb][idx & block_mask]; @@ -107,42 +107,42 @@ public: 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); + unsigned vertex(float* x, float* y); + void add_vertex(float x, float y, unsigned cmd); void end_poly(); private: void allocate_block(unsigned nb); - unsigned char* storage_ptrs(FX_FLOAT** xy_ptr); + unsigned char* storage_ptrs(float** xy_ptr); private: unsigned m_total_vertices; unsigned m_total_blocks; unsigned m_max_blocks; - FX_FLOAT** m_coord_blocks; + float** m_coord_blocks; unsigned char** m_cmd_blocks; unsigned m_iterator; }; -inline unsigned path_storage::vertex(FX_FLOAT* x, FX_FLOAT* y) +inline unsigned path_storage::vertex(float* x, 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 +inline unsigned path_storage::prev_vertex(float* x, 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 +inline unsigned path_storage::last_vertex(float* x, 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) +inline unsigned char* path_storage::storage_ptrs(float** xy_ptr) { unsigned nb = m_total_vertices >> block_shift; if(nb >= m_total_blocks) { @@ -151,20 +151,20 @@ inline unsigned char* path_storage::storage_ptrs(FX_FLOAT** xy_ptr) *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) +inline void path_storage::add_vertex(float x, float y, unsigned cmd) { - FX_FLOAT* coord_ptr = 0; + 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) +inline void path_storage::move_to(float x, float y) { add_vertex(x, y, path_cmd_move_to); } -inline void path_storage::line_to(FX_FLOAT x, FX_FLOAT y) +inline void path_storage::line_to(float x, float y) { add_vertex(x, y, path_cmd_line_to); } diff --git a/third_party/agg23/agg_rasterizer_scanline_aa.h b/third_party/agg23/agg_rasterizer_scanline_aa.h index fc28290f54..c747ee379e 100644 --- a/third_party/agg23/agg_rasterizer_scanline_aa.h +++ b/third_party/agg23/agg_rasterizer_scanline_aa.h @@ -45,7 +45,7 @@ enum poly_base_scale_e { poly_base_size = 1 << poly_base_shift, poly_base_mask = poly_base_size - 1 }; -inline int poly_coord(FX_FLOAT c) +inline int poly_coord(float c) { return int(c * poly_base_size); } @@ -219,14 +219,14 @@ public: m_outline.reset(); m_status = status_initial; } - void clip_box(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2) + void clip_box(float x1, float y1, float x2, float y2) { m_clip_box = rect(poly_coord(x1), poly_coord(y1), poly_coord(x2), poly_coord(y2)); m_clip_box.normalize(); m_clipping = true; } - void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) + void add_vertex(float x, float y, unsigned cmd) { if(is_close(cmd)) { close_polygon(); @@ -374,8 +374,8 @@ public: template void add_path(VertexSource& vs, unsigned path_id = 0) { - FX_FLOAT x; - FX_FLOAT y; + float x; + float y; unsigned cmd; vs.rewind(path_id); while(!is_stop(cmd = vs.vertex(&x, &y))) { @@ -385,8 +385,8 @@ public: template void add_path_transformed(VertexSource& vs, const CFX_Matrix* pMatrix, unsigned path_id = 0) { - FX_FLOAT x; - FX_FLOAT y; + float x; + float y; unsigned cmd; vs.rewind(path_id); while(!is_stop(cmd = vs.vertex(&x, &y))) { diff --git a/third_party/agg23/agg_shorten_path.h b/third_party/agg23/agg_shorten_path.h index d7eb4be018..2f62ec52d2 100644 --- a/third_party/agg23/agg_shorten_path.h +++ b/third_party/agg23/agg_shorten_path.h @@ -20,11 +20,11 @@ namespace agg { template -void shorten_path(VertexSequence& vs, FX_FLOAT s, unsigned closed = 0) +void shorten_path(VertexSequence& vs, float s, unsigned closed = 0) { typedef typename VertexSequence::value_type vertex_type; if(s > 0 && vs.size() > 1) { - FX_FLOAT d; + float d; int n = int(vs.size() - 2); while(n) { d = vs[n].dist; @@ -42,8 +42,8 @@ void shorten_path(VertexSequence& vs, FX_FLOAT s, unsigned closed = 0) 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; + float x = prev.x + (last.x - prev.x) * d; + float y = prev.y + (last.y - prev.y) * d; last.x = x; last.y = y; if(!prev(last)) { diff --git a/third_party/agg23/agg_vcgen_dash.cpp b/third_party/agg23/agg_vcgen_dash.cpp index bd5a2122a2..cfeab0764e 100644 --- a/third_party/agg23/agg_vcgen_dash.cpp +++ b/third_party/agg23/agg_vcgen_dash.cpp @@ -44,7 +44,7 @@ void vcgen_dash::remove_all_dashes() m_curr_dash_start = 0; m_curr_dash = 0; } -void vcgen_dash::add_dash(FX_FLOAT dash_len, FX_FLOAT gap_len) +void vcgen_dash::add_dash(float dash_len, float gap_len) { if(m_num_dashes < max_dashes) { m_total_dash_len += dash_len + gap_len; @@ -52,12 +52,12 @@ void vcgen_dash::add_dash(FX_FLOAT dash_len, FX_FLOAT gap_len) m_dashes[m_num_dashes++] = gap_len; } } -void vcgen_dash::dash_start(FX_FLOAT ds) +void vcgen_dash::dash_start(float ds) { m_dash_start = ds; calc_dash_start(FXSYS_fabs(ds)); } -void vcgen_dash::calc_dash_start(FX_FLOAT ds) +void vcgen_dash::calc_dash_start(float ds) { m_curr_dash = 0; m_curr_dash_start = 0; @@ -81,7 +81,7 @@ void vcgen_dash::remove_all() m_src_vertices.remove_all(); m_closed = 0; } -void vcgen_dash::add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) +void vcgen_dash::add_vertex(float x, float y, unsigned cmd) { m_status = initial; if(is_move_to(cmd)) { @@ -103,7 +103,7 @@ void vcgen_dash::rewind(unsigned) m_status = ready; m_src_vertex = 0; } -unsigned vcgen_dash::vertex(FX_FLOAT* x, FX_FLOAT* y) +unsigned vcgen_dash::vertex(float* x, float* y) { unsigned cmd = path_cmd_move_to; while(!is_stop(cmd)) { @@ -127,7 +127,7 @@ unsigned vcgen_dash::vertex(FX_FLOAT* x, FX_FLOAT* y) } return path_cmd_move_to; case polyline: { - FX_FLOAT dash_rest = m_dashes[m_curr_dash] - m_curr_dash_start; + 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; diff --git a/third_party/agg23/agg_vcgen_dash.h b/third_party/agg23/agg_vcgen_dash.h index 9c3aa630c2..7702fa7adc 100644 --- a/third_party/agg23/agg_vcgen_dash.h +++ b/third_party/agg23/agg_vcgen_dash.h @@ -38,9 +38,9 @@ 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) + void add_dash(float dash_len, float gap_len); + void dash_start(float ds); + void shorten(float s) { m_shorten = s; } @@ -49,21 +49,21 @@ public: return m_shorten; } void remove_all(); - void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd); + void add_vertex(float x, float y, unsigned cmd); void rewind(unsigned path_id); - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); + unsigned vertex(float* x, 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; + void calc_dash_start(float ds); + float m_dashes[max_dashes]; + float m_total_dash_len; unsigned m_num_dashes; - FX_FLOAT m_dash_start; - FX_FLOAT m_shorten; - FX_FLOAT m_curr_dash_start; + float m_dash_start; + float m_shorten; + float m_curr_dash_start; unsigned m_curr_dash; - FX_FLOAT m_curr_rest; + float m_curr_rest; const vertex_dist* m_v1; const vertex_dist* m_v2; vertex_storage m_src_vertices; diff --git a/third_party/agg23/agg_vcgen_stroke.cpp b/third_party/agg23/agg_vcgen_stroke.cpp index 03225b1649..a59abf0022 100644 --- a/third_party/agg23/agg_vcgen_stroke.cpp +++ b/third_party/agg23/agg_vcgen_stroke.cpp @@ -51,7 +51,7 @@ void vcgen_stroke::remove_all() m_closed = 0; m_status = initial; } -void vcgen_stroke::add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) +void vcgen_stroke::add_vertex(float x, float y, unsigned cmd) { m_status = initial; if(is_move_to(cmd)) { @@ -64,13 +64,13 @@ void vcgen_stroke::add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd) } } } -static inline void calc_butt_cap(FX_FLOAT* cap, +static inline void calc_butt_cap(float* cap, const vertex_dist& v0, const vertex_dist& v1, - FX_FLOAT len, - FX_FLOAT width) { - FX_FLOAT dx = (v1.y - v0.y) * width / len; - FX_FLOAT dy = (v1.x - v0.x) * width / len; + float len, + float width) { + float dx = (v1.y - v0.y) * width / len; + float dy = (v1.x - v0.x) * width / len; cap[0] = v0.x - dx; cap[1] = v0.y + dy; cap[2] = v0.x + dx; @@ -88,7 +88,7 @@ void vcgen_stroke::rewind(unsigned) m_src_vertex = 0; m_out_vertex = 0; } -unsigned vcgen_stroke::vertex(FX_FLOAT* x, FX_FLOAT* y) +unsigned vcgen_stroke::vertex(float* x, float* y) { unsigned cmd = path_cmd_line_to; line_join_e curj; diff --git a/third_party/agg23/agg_vcgen_stroke.h b/third_party/agg23/agg_vcgen_stroke.h index 84fadd6ed8..23142d37f6 100644 --- a/third_party/agg23/agg_vcgen_stroke.h +++ b/third_party/agg23/agg_vcgen_stroke.h @@ -61,52 +61,52 @@ public: { return m_inner_join; } - void width(FX_FLOAT w) + void width(float w) { m_width = w / 2; } - void miter_limit(FX_FLOAT ml) + void miter_limit(float ml) { m_miter_limit = ml; } - void miter_limit_theta(FX_FLOAT t); - void inner_miter_limit(FX_FLOAT ml) + void miter_limit_theta(float t); + void inner_miter_limit(float ml) { m_inner_miter_limit = ml; } - void approximation_scale(FX_FLOAT as) + void approximation_scale(float as) { m_approx_scale = as; } - FX_FLOAT width() const + float width() const { return m_width * 2; } - FX_FLOAT miter_limit() const + float miter_limit() const { return m_miter_limit; } - FX_FLOAT inner_miter_limit() const + float inner_miter_limit() const { return m_inner_miter_limit; } - FX_FLOAT approximation_scale() const + float approximation_scale() const { return m_approx_scale; } void remove_all(); - void add_vertex(FX_FLOAT x, FX_FLOAT y, unsigned cmd); + void add_vertex(float x, float y, unsigned cmd); void rewind(unsigned path_id); - unsigned vertex(FX_FLOAT* x, FX_FLOAT* y); + unsigned vertex(float* x, 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; + float m_width; + float m_miter_limit; + float m_inner_miter_limit; + float m_approx_scale; line_cap_e m_line_cap; line_join_e m_line_join; inner_join_e m_inner_join; diff --git a/third_party/agg23/agg_vertex_sequence.h b/third_party/agg23/agg_vertex_sequence.h index 6600bf2085..448e57b04d 100644 --- a/third_party/agg23/agg_vertex_sequence.h +++ b/third_party/agg23/agg_vertex_sequence.h @@ -69,13 +69,13 @@ void vertex_sequence::close(bool closed) } } } -const FX_FLOAT vertex_dist_epsilon = 1e-14f; +const float vertex_dist_epsilon = 1e-14f; struct vertex_dist { - FX_FLOAT x; - FX_FLOAT y; - FX_FLOAT dist; + float x; + float y; + float dist; vertex_dist() {} - vertex_dist(FX_FLOAT x_, FX_FLOAT y_) : + vertex_dist(float x_, float y_) : x(x_), y(y_), dist(0) @@ -90,7 +90,7 @@ struct vertex_dist { 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_cmd(float x_, float y_, unsigned cmd_) : vertex_dist(x_, y_), cmd(cmd_) { -- cgit v1.2.3