agg/inc/agg_renderer_scanline.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_RENDERER_SCANLINE_INCLUDED
  17 #define AGG_RENDERER_SCANLINE_INCLUDED
  18
  19 #include "agg_basics.h"
  20 #include "agg_renderer_base.h"
  21 #include "agg_render_scanlines.h"
  22
  23 namespace agg
  24 {
  25
  26     //====================================================renderer_scanline_aa
  27     template<class BaseRenderer, class SpanGenerator> class renderer_scanline_aa
  28     {
  29     public:
  30         typedef BaseRenderer base_ren_type;
  31
  32         //--------------------------------------------------------------------
  33         renderer_scanline_aa(base_ren_type& ren, SpanGenerator& span_gen) :
  34             m_ren(&ren),
  35             m_span_gen(&span_gen)
  36         {
  37         }
  38
  39         //--------------------------------------------------------------------
  40         void prepare(unsigned max_span_len)
  41         {
  42             m_span_gen->prepare(max_span_len);
  43         }
  44
  45         //--------------------------------------------------------------------
  46         template<class Scanline> void render(const Scanline& sl)
  47         {
  48             int y = sl.y();
  49             m_ren->first_clip_box();
  50             do
  51             {
  52                 int xmin = m_ren->xmin();
  53                 int xmax = m_ren->xmax();
  54
  55                 if(y >= m_ren->ymin() && y <= m_ren->ymax())
  56                 {
  57                     unsigned num_spans = sl.num_spans();
  58                     typename Scanline::const_iterator span = sl.begin();
  59                     do
  60                     {
  61                         int x = span->x;
  62                         int len = span->len;
  63                         bool solid = false;
  64                         const typename Scanline::cover_type* covers = span->covers;
  65
  66                         if(len < 0)
  67                         {
  68                             solid = true;
  69                             len = -len;
  70                         }
  71
  72                         if(x < xmin)
  73                         {
  74                             len -= xmin - x;
  75                             if(!solid)
  76                             {
  77                                 covers += xmin - x;
  78                             }
  79                             x = xmin;
  80                         }
  81
  82                         if(len > 0)
  83                         {
  84                             if(x + len > xmax)
  85                             {
  86                                 len = xmax - x + 1;
  87                             }
  88                             if(len > 0)
  89                             {
  90                                 m_ren->blend_color_hspan_no_clip(
  91                                     x, y, len,
  92                                     m_span_gen->generate(x, y, len),
  93                                     solid ? 0 : covers,
  94                                     *covers);
  95                             }
  96                         }
  97                         ++span;
  98                     }
  99                     while(--num_spans);
 100                 }
 101             }
 102             while(m_ren->next_clip_box());
 103         }
 104
 105     private:
 106         base_ren_type* m_ren;
 107         SpanGenerator* m_span_gen;
 108     };
 109
 110
 111
 112
 113     //==============================================renderer_scanline_aa_opaque
 114     template<class BaseRenderer, class SpanGenerator> class renderer_scanline_aa_opaque
 115     {
 116     public:
 117         typedef BaseRenderer base_ren_type;
 118
 119         //--------------------------------------------------------------------
 120         renderer_scanline_aa_opaque(base_ren_type& ren, SpanGenerator& span_gen) :
 121             m_ren(&ren),
 122             m_span_gen(&span_gen)
 123         {
 124         }
 125
 126         //--------------------------------------------------------------------
 127         void prepare(unsigned max_span_len)
 128         {
 129             m_span_gen->prepare(max_span_len);
 130         }
 131
 132         //--------------------------------------------------------------------
 133         template<class Scanline> void render(const Scanline& sl)
 134         {
 135             int y = sl.y();
 136             m_ren->first_clip_box();
 137             do
 138             {
 139                 int xmin = m_ren->xmin();
 140                 int xmax = m_ren->xmax();
 141
 142                 if(y >= m_ren->ymin() && y <= m_ren->ymax())
 143                 {
 144                     unsigned num_spans = sl.num_spans();
 145                     typename Scanline::const_iterator span = sl.begin();
 146                     do
 147                     {
 148                         int x = span->x;
 149                         int len = span->len;
 150                         bool solid = false;
 151                         const typename Scanline::cover_type* covers = span->covers;
 152
 153                         if(len < 0)
 154                         {
 155                             solid = true;
 156                             len = -len;
 157                         }
 158
 159                         if(x < xmin)
 160                         {
 161                             len -= xmin - x;
 162                             if(!solid)
 163                             {
 164                                 covers += xmin - x;
 165                             }
 166                             x = xmin;
 167                         }
 168
 169                         if(len > 0)
 170                         {
 171                             if(x + len > xmax)
 172                             {
 173                                 len = xmax - x + 1;
 174                             }
 175                             if(len > 0)
 176                             {
 177                                 m_ren->blend_opaque_color_hspan_no_clip(
 178                                     x, y, len,
 179                                     m_span_gen->generate(x, y, len),
 180                                     solid ? 0 : covers,
 181                                     *covers);
 182                             }
 183                         }
 184                         ++span;
 185                     }
 186                     while(--num_spans);
 187                 }
 188             }
 189             while(m_ren->next_clip_box());
 190         }
 191
 192     private:
 193         base_ren_type* m_ren;
 194         SpanGenerator* m_span_gen;
 195     };
 196
 197
 198
 199     //==============================================renderer_scanline_aa_solid
 200     template<class BaseRenderer> class renderer_scanline_aa_solid
 201     {
 202     public:
 203         typedef BaseRenderer base_ren_type;
 204         typedef typename base_ren_type::color_type color_type;
 205
 206         //--------------------------------------------------------------------
 207         renderer_scanline_aa_solid(base_ren_type& ren) :
 208             m_ren(&ren)
 209         {
 210         }
 211
 212         //--------------------------------------------------------------------
 213         void color(const color_type& c) { m_color = c; }
 214         const color_type& color() const { return m_color; }
 215
 216         //--------------------------------------------------------------------
 217         void prepare(unsigned) {}
 218
 219         //--------------------------------------------------------------------
 220         template<class Scanline> void render(const Scanline& sl)
 221         {
 222             int y = sl.y();
 223             unsigned num_spans = sl.num_spans();
 224             typename Scanline::const_iterator span = sl.begin();
 225
 226             do
 227             {
 228                 int x = span->x;
 229                 if(span->len > 0)
 230                 {
 231                     m_ren->blend_solid_hspan(x, y, (unsigned)span->len,
 232                                              m_color,
 233                                              span->covers);
 234                 }
 235                 else
 236                 {
 237                     m_ren->blend_hline(x, y, (unsigned)(x - span->len - 1),
 238                                        m_color,
 239                                        *(span->covers));
 240                 }
 241                 ++span;
 242             }
 243             while(--num_spans);
 244         }
 245
 246     private:
 247         base_ren_type* m_ren;
 248         color_type m_color;
 249     };
 250
 251
 252
 253
 254
 255
 256
 257     //===================================================renderer_scanline_bin
 258     template<class BaseRenderer, class SpanGenerator> class renderer_scanline_bin
 259     {
 260     public:
 261         typedef BaseRenderer base_ren_type;
 262
 263         //--------------------------------------------------------------------
 264         renderer_scanline_bin(base_ren_type& ren, SpanGenerator& span_gen) :
 265             m_ren(&ren),
 266             m_span_gen(&span_gen)
 267         {
 268         }
 269
 270         //--------------------------------------------------------------------
 271         void prepare(unsigned max_span_len)
 272         {
 273             m_span_gen->prepare(max_span_len);
 274         }
 275
 276         //--------------------------------------------------------------------
 277         template<class Scanline> void render(const Scanline& sl)
 278         {
 279             int y = sl.y();
 280             m_ren->first_clip_box();
 281             do
 282             {
 283                 int xmin = m_ren->xmin();
 284                 int xmax = m_ren->xmax();
 285
 286                 if(y >= m_ren->ymin() && y <= m_ren->ymax())
 287                 {
 288                     unsigned num_spans = sl.num_spans();
 289                     typename Scanline::const_iterator span = sl.begin();
 290                     do
 291                     {
 292                         int x = span->x;
 293                         int len = span->len;
 294
 295                         if(len < 0) len = -len;
 296                         if(x < xmin)
 297                         {
 298                             len -= xmin - x;
 299                             x = xmin;
 300                         }
 301                         if(len > 0)
 302                         {
 303                             if(x + len > xmax)
 304                             {
 305                                 len = xmax - x + 1;
 306                             }
 307                             if(len > 0)
 308                             {
 309                                 m_ren->blend_color_hspan_no_clip(
 310                                     x, y, len,
 311                                     m_span_gen->generate(x, y, len),
 312                                     0);
 313                             }
 314                         }
 315                         ++span;
 316                     }
 317                     while(--num_spans);
 318                 }
 319             }
 320             while(m_ren->next_clip_box());
 321         }
 322
 323     private:
 324         base_ren_type* m_ren;
 325         SpanGenerator* m_span_gen;
 326     };
 327
 328
 329
 330     //===============================================renderer_scanline_bin_opaque
 331     template<class BaseRenderer, class SpanGenerator> class renderer_scanline_bin_opaque
 332     {
 333     public:
 334         typedef BaseRenderer base_ren_type;
 335
 336         //--------------------------------------------------------------------
 337         renderer_scanline_bin_opaque(base_ren_type& ren, SpanGenerator& span_gen) :
 338             m_ren(&ren),
 339             m_span_gen(&span_gen)
 340         {
 341         }
 342
 343         //--------------------------------------------------------------------
 344         void prepare(unsigned max_span_len)
 345         {
 346             m_span_gen->prepare(max_span_len);
 347         }
 348
 349         //--------------------------------------------------------------------
 350         template<class Scanline> void render(const Scanline& sl)
 351         {
 352             int y = sl.y();
 353             m_ren->first_clip_box();
 354             do
 355             {
 356                 int xmin = m_ren->xmin();
 357                 int xmax = m_ren->xmax();
 358
 359                 if(y >= m_ren->ymin() && y <= m_ren->ymax())
 360                 {
 361                     unsigned num_spans = sl.num_spans();
 362                     typename Scanline::const_iterator span = sl.begin();
 363                     do
 364                     {
 365                         int x = span->x;
 366                         int len = span->len;
 367
 368                         if(len < 0) len = -len;
 369                         if(x < xmin)
 370                         {
 371                             len -= xmin - x;
 372                             x = xmin;
 373                         }
 374                         if(len > 0)
 375                         {
 376                             if(x + len > xmax)
 377                             {
 378                                 len = xmax - x + 1;
 379                             }
 380                             if(len > 0)
 381                             {
 382                                 m_ren->blend_opaque_color_hspan_no_clip(
 383                                     x, y, len,
 384                                     m_span_gen->generate(x, y, len),
 385                                     0);
 386                             }
 387                         }
 388                         ++span;
 389                     }
 390                     while(--num_spans);
 391                 }
 392             }
 393             while(m_ren->next_clip_box());
 394         }
 395
 396     private:
 397         base_ren_type* m_ren;
 398         SpanGenerator* m_span_gen;
 399     };
 400
 401
 402
 403
 404     //=============================================renderer_scanline_bin_solid
 405     template<class BaseRenderer> class renderer_scanline_bin_solid
 406     {
 407     public:
 408         typedef BaseRenderer base_ren_type;
 409         typedef typename base_ren_type::color_type color_type;
 410
 411         //--------------------------------------------------------------------
 412         renderer_scanline_bin_solid(base_ren_type& ren) :
 413             m_ren(&ren)
 414         {
 415         }
 416
 417         //--------------------------------------------------------------------
 418         void color(const color_type& c) { m_color = c; }
 419         const color_type& color() const { return m_color; }
 420
 421         //--------------------------------------------------------------------
 422         void prepare(unsigned) {}
 423
 424         //--------------------------------------------------------------------
 425         template<class Scanline> void render(const Scanline& sl)
 426         {
 427             unsigned num_spans = sl.num_spans();
 428             typename Scanline::const_iterator span = sl.begin();
 429             do
 430             {
 431                 m_ren->blend_hline(span->x,
 432                                    sl.y(),
 433                                    span->x - 1 + ((span->len < 0) ?
 434                                                      -span->len :
 435                                                       span->len),
 436                                    m_color,
 437                                    cover_full);
 438                 ++span;
 439             }
 440             while(--num_spans);
 441         }
 442
 443     private:
 444         base_ren_type* m_ren;
 445         color_type m_color;
 446     };
 447
 448 }
 449
 450 #endif