agg/inc/agg_basics.h

   1 //----------------------------------------------------------------------------
   2 // Anti-Grain Geometry - Version 2.3
   3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
   4 //
   5 // Permission to copy, use, modify, sell and distribute this software
   6 // is granted provided this copyright notice appears in all copies.
   7 // This software is provided "as is" without express or implied
   8 // warranty, and with no claim as to its suitability for any purpose.
   9 //
  10 //----------------------------------------------------------------------------
  11 // Contact: mcseem@antigrain.com
  12 //          mcseemagg@yahoo.com
  13 //          http://www.antigrain.com
  14 //----------------------------------------------------------------------------
  15
  16 #ifndef AGG_BASICS_INCLUDED
  17 #define AGG_BASICS_INCLUDED
  18
  19 #include "agg_config.h"
  20
  21 //-------------------------------------------------------- Default basic types
  22 //
  23 // If the compiler has different capacity of the basic types you can redefine
  24 // them via the compiler command line or by generating agg_config.h that is
  25 // empty by default.
  26 //
  27 #ifndef AGG_INT8
  28 #define AGG_INT8 signed char
  29 #endif
  30
  31 #ifndef AGG_INT8U
  32 #define AGG_INT8U unsigned char
  33 #endif
  34
  35 #ifndef AGG_INT16
  36 #define AGG_INT16 short
  37 #endif
  38
  39 #ifndef AGG_INT16U
  40 #define AGG_INT16U unsigned short
  41 #endif
  42
  43 #ifndef AGG_INT32
  44 #define AGG_INT32 int
  45 #endif
  46
  47 #ifndef AGG_INT32U
  48 #define AGG_INT32U unsigned
  49 #endif
  50
  51 #ifndef AGG_INT64
  52 #if defined(_MSC_VER)
  53 #define AGG_INT64 signed __int64
  54 #else
  55 #define AGG_INT64 signed long long
  56 #endif
  57 #endif
  58
  59 #ifndef AGG_INT64U
  60 #if defined(_MSC_VER)
  61 #define AGG_INT64U unsigned __int64
  62 #else
  63 #define AGG_INT64U unsigned long long
  64 #endif
  65 #endif
  66
  67 //------------------------------------------------ Some fixes for MS Visual C++
  68 #if defined(_MSC_VER)
  69 #pragma warning(disable:4786) // Identifier was truncated...
  70 #endif
  71
  72 #if defined(_MSC_VER)
  73 #define AGG_INLINE __forceinline
  74 #else
  75 #define AGG_INLINE inline
  76 #endif
  77
  78 namespace agg
  79 {
  80     //-------------------------------------------------------------------------
  81     typedef AGG_INT8   int8;         //----int8
  82     typedef AGG_INT8U  int8u;        //----int8u
  83     typedef AGG_INT16  int16;        //----int16
  84     typedef AGG_INT16U int16u;       //----int16u
  85     typedef AGG_INT32  int32;        //----int32
  86     typedef AGG_INT32U int32u;       //----int32u
  87     typedef AGG_INT64  int64;        //----int64
  88     typedef AGG_INT64U int64u;       //----int64u
  89
  90     //-------------------------------------------------------------------------
  91     typedef unsigned char cover_type;    //----cover_type
  92     enum
  93     {
  94         cover_shift = 8,                 //----cover_shift
  95         cover_size  = 1 << cover_shift,  //----cover_size
  96         cover_mask  = cover_size - 1,    //----cover_mask
  97         cover_none  = 0,                 //----cover_none
  98         cover_full  = cover_mask         //----cover_full
  99     };
 100
 101
 102     //-----------------------------------------------------------------------pi
 103     const double pi = 3.14159265358979323846;
 104
 105     //------------------------------------------------------------------deg2rad
 106     inline double deg2rad(double deg)
 107     {
 108         return deg * pi / 180.0;
 109     }
 110
 111     //------------------------------------------------------------------rad2deg
 112     inline double rad2deg(double rad)
 113     {
 114         return rad * 180.0 / pi;
 115     }
 116
 117     //----------------------------------------------------------------rect_base
 118     template<class T> struct rect_base
 119     {
 120         typedef rect_base<T> self_type;
 121         T x1;
 122         T y1;
 123         T x2;
 124         T y2;
 125
 126         rect_base() {}
 127         rect_base(T x1_, T y1_, T x2_, T y2_) :
 128             x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
 129
 130         const self_type& normalize()
 131         {
 132             T t;
 133             if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
 134             if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
 135             return *this;
 136         }
 137
 138         bool clip(const self_type& r)
 139         {
 140             if(x2 > r.x2) x2 = r.x2;
 141             if(y2 > r.y2) y2 = r.y2;
 142             if(x1 < r.x1) x1 = r.x1;
 143             if(y1 < r.y1) y1 = r.y1;
 144             return x1 <= x2 && y1 <= y2;
 145         }
 146
 147         bool is_valid() const
 148         {
 149             return x1 <= x2 && y1 <= y2;
 150         }
 151     };
 152
 153     //-----------------------------------------------------intersect_rectangles
 154     template<class Rect>
 155     inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
 156     {
 157         Rect r = r1;
 158
 159         // First process x2,y2 because the other order
 160         // results in Internal Compiler Error under
 161         // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in
 162         // case of "Maximize Speed" optimization option.
 163         //-----------------
 164         if(r.x2 > r2.x2) r.x2 = r2.x2;
 165         if(r.y2 > r2.y2) r.y2 = r2.y2;
 166         if(r.x1 < r2.x1) r.x1 = r2.x1;
 167         if(r.y1 < r2.y1) r.y1 = r2.y1;
 168         return r;
 169     }
 170
 171
 172     //---------------------------------------------------------unite_rectangles
 173     template<class Rect>
 174     inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
 175     {
 176         Rect r = r1;
 177         if(r.x2 < r2.x2) r.x2 = r2.x2;
 178         if(r.y2 < r2.y2) r.y2 = r2.y2;
 179         if(r.x1 > r2.x1) r.x1 = r2.x1;
 180         if(r.y1 > r2.y1) r.y1 = r2.y1;
 181         return r;
 182     }
 183
 184     typedef rect_base<int>    rect;   //----rect
 185     typedef rect_base<double> rect_d; //----rect_d
 186
 187     //---------------------------------------------------------path_commands_e
 188     enum path_commands_e
 189     {
 190         path_cmd_stop     = 0,        //----path_cmd_stop
 191         path_cmd_move_to  = 1,        //----path_cmd_move_to
 192         path_cmd_line_to  = 2,        //----path_cmd_line_to
 193         path_cmd_curve3   = 3,        //----path_cmd_curve3
 194         path_cmd_curve4   = 4,        //----path_cmd_curve4
 195         path_cmd_end_poly = 6,        //----path_cmd_end_poly
 196         path_cmd_mask     = 0x0F      //----path_cmd_mask
 197     };
 198
 199     //------------------------------------------------------------path_flags_e
 200     enum path_flags_e
 201     {
 202         path_flags_none  = 0,         //----path_flags_none
 203         path_flags_ccw   = 0x10,      //----path_flags_ccw
 204         path_flags_cw    = 0x20,      //----path_flags_cw
 205         path_flags_close = 0x40,      //----path_flags_close
 206         path_flags_mask  = 0xF0       //----path_flags_mask
 207     };
 208
 209     //---------------------------------------------------------------is_vertex
 210     inline bool is_vertex(unsigned c)
 211     {
 212         return c >= path_cmd_move_to && c < path_cmd_end_poly;
 213     }
 214
 215     //-----------------------------------------------------------------is_stop
 216     inline bool is_stop(unsigned c)
 217     {
 218         return c == path_cmd_stop;
 219     }
 220
 221     //--------------------------------------------------------------is_move_to
 222     inline bool is_move_to(unsigned c)
 223     {
 224         return c == path_cmd_move_to;
 225     }
 226
 227     //--------------------------------------------------------------is_line_to
 228     inline bool is_line_to(unsigned c)
 229     {
 230         return c == path_cmd_line_to;
 231     }
 232
 233     //----------------------------------------------------------------is_curve
 234     inline bool is_curve(unsigned c)
 235     {
 236         return c == path_cmd_curve3 || c == path_cmd_curve4;
 237     }
 238
 239     //---------------------------------------------------------------is_curve3
 240     inline bool is_curve3(unsigned c)
 241     {
 242         return c == path_cmd_curve3;
 243     }
 244
 245     //---------------------------------------------------------------is_curve4
 246     inline bool is_curve4(unsigned c)
 247     {
 248         return c == path_cmd_curve4;
 249     }
 250
 251     //-------------------------------------------------------------is_end_poly
 252     inline bool is_end_poly(unsigned c)
 253     {
 254         return (c & path_cmd_mask) == path_cmd_end_poly;
 255     }
 256
 257     //----------------------------------------------------------------is_close
 258     inline bool is_close(unsigned c)
 259     {
 260         return (c & ~(path_flags_cw | path_flags_ccw)) ==
 261                (((bool)path_cmd_end_poly) | ((bool)path_flags_close));
 262     }
 263
 264     //------------------------------------------------------------is_next_poly
 265     inline bool is_next_poly(unsigned c)
 266     {
 267         return is_stop(c) || is_move_to(c) || is_end_poly(c);
 268     }
 269
 270     //-------------------------------------------------------------------is_cw
 271     inline bool is_cw(unsigned c)
 272     {
 273         return (c & path_flags_cw) != 0;
 274     }
 275
 276     //------------------------------------------------------------------is_ccw
 277     inline bool is_ccw(unsigned c)
 278     {
 279         return (c & path_flags_ccw) != 0;
 280     }
 281
 282     //-------------------------------------------------------------is_oriented
 283     inline bool is_oriented(unsigned c)
 284     {
 285         return (c & (path_flags_cw | path_flags_ccw)) != 0;
 286     }
 287
 288     //---------------------------------------------------------------is_closed
 289     inline bool is_closed(unsigned c)
 290     {
 291         return (c & path_flags_close) != 0;
 292     }
 293
 294     //----------------------------------------------------------get_close_flag
 295     inline unsigned get_close_flag(unsigned c)
 296     {
 297         return c & path_flags_close;
 298     }
 299
 300     //-------------------------------------------------------clear_orientation
 301     inline unsigned clear_orientation(unsigned c)
 302     {
 303         return c & ~(path_flags_cw | path_flags_ccw);
 304     }
 305
 306     //---------------------------------------------------------get_orientation
 307     inline unsigned get_orientation(unsigned c)
 308     {
 309         return c & (path_flags_cw | path_flags_ccw);
 310     }
 311
 312     //---------------------------------------------------------set_orientation
 313     inline unsigned set_orientation(unsigned c, unsigned o)
 314     {
 315         return clear_orientation(c) | o;
 316     }
 317
 318     //--------------------------------------------------------------point_type
 319     struct point_type
 320     {
 321         double x, y;
 322
 323         point_type() {}
 324         point_type(double x_, double y_) : x(x_), y(y_) {}
 325     };
 326
 327     //-------------------------------------------------------------vertex_type
 328     struct vertex_type
 329     {
 330         double   x, y;
 331         unsigned cmd;
 332
 333         vertex_type() {}
 334         vertex_type(double x_, double y_, unsigned cmd_) :
 335             x(x_), y(y_), cmd(cmd_) {}
 336     };
 337
 338
 339 }
 340
 341
 342 #endif
 343