libs/agg/agg_scanline_boolean_algebra.h

41                           Scanline& sl) const
43             sl.add_span(x, len, cover_full);
93                           Scanline& sl) const
95             sl.add_span(x, len, cover_full);
114                           Scanline& sl) const
118                 sl.add_span(x, len, *span->covers);
125                 sl.add_cells(x, len, covers);
136     // The result is added to the "sl" scanline.
156                           Scanline& sl) const
179                     sl.add_cell(x++,
192                     sl.add_cells(x, len, covers2);
199                         sl.add_cell(x++,
213                     sl.add_cells(x, len, covers1);
220                         sl.add_cell(x++,
231                 sl.add_span(x, len,
248     // The result is added to the "sl" scanline.
268                           Scanline& sl) const
293                     sl.add_cell(x++,
306                     sl.add_span(x, len, cover_full);
315                         sl.add_cell(x++,
329                     sl.add_span(x, len, cover_full);
338                         sl.add_cell(x++,
351                 sl.add_span(x, len,
418     // The result is added to the "sl" scanline.
439                           Scanline& sl) const
462                     if(cover) sl.add_cell(x, cover);
474                     if(cover) sl.add_cell(x, cover);
486                     if(cover) sl.add_cell(x, cover);
494                 if(cover) sl.add_span(x, len, cover);
508     // The result is added to the "sl" scanline.
528                           Scanline& sl) const
553                         sl.add_cell(x,
571                         sl.add_cell(x,
591                             sl.add_cell(x,
606                     sl.add_span(x, len,
627                                     Scanline& sl,
631         sl.reset_spans();
636             add_span(span, span->x, abs((int)span->len), sl);
640         sl.finalize(sl1.y());
641         ren.render(sl);
651     // Intersect two scanlines, "sl1" and "sl2" and generate a new "sl" one.
663                                    Scanline& sl,
666         sl.reset_spans();
699                 combine_spans(span1, span2, xb1, xe1 - xb1 + 1, sl);
741     // "sl" is ised as the resulting scanline to render it.
756                                 Scanline& sl, Renderer& ren,
779         sl.reset(ir.x1, ir.x2);
810                 sbool_intersect_scanlines(sl1, sl2, sl, combine_spans);
811                 if(sl.num_spans())
813                     sl.finalize(sl1.y());
814                     ren.render(sl);
829     // Unite two scanlines, "sl1" and "sl2" and generate a new "sl" one.
843                                Scanline& sl,
848         sl.reset_spans();
928                     add_span1(span1, xb1, xb2 - xb1, sl);
934                     add_span2(span2, xb2, xb1 - xb2, sl);
940                 combine_spans(span1, span2, xb, len, sl);
982                         add_span1(span1, xb1, xe1 - xb1 + 1, sl);
993                         add_span2(span2, xb2, xe2 - xb2 + 1, sl);
1012     // "sl" is ised as the resulting scanline to render it.
1029                             Scanline& sl, Renderer& ren,
1060         sl.reset(ur.x1, ur.x2);
1087                     sbool_unite_scanlines(sl1, sl2, sl,
1089                     if(sl.num_spans())
1091                         sl.finalize(sl1.y());
1092                         ren.render(sl);
1101                         sbool_add_spans_and_render(sl1, sl, ren, add_span1);
1106                         sbool_add_spans_and_render(sl2, sl, ren, add_span2);
1115                     sbool_add_spans_and_render(sl1, sl, ren, add_span1);
1120                     sbool_add_spans_and_render(sl2, sl, ren, add_span2);
1141     // "sl" is ised as the resulting scanline to render it.
1157                                Scanline& sl, Renderer& ren,
1173         sl.reset(sg1.min_x(), sg1.max_x());
1207                 sbool_unite_scanlines(sl1, sl2, sl, add_span1, add_span2, combine_spans);
1208                 if(sl.num_spans())
1210                     sl.finalize(sl1.y());
1211                     ren.render(sl);
1216                 sbool_add_spans_and_render(sl1, sl, ren, add_span1);
1238     // "sl" is ised as the resulting scanline to render it.
1250                                    Scanline& sl, Renderer& ren)
1253         sbool_intersect_shapes(sg1, sg2, sl1, sl2, sl, ren, combine_functor);
1272                                     Scanline& sl, Renderer& ren)
1275         sbool_intersect_shapes(sg1, sg2, sl1, sl2, sl, ren, combine_functor);
1294                                Scanline& sl, Renderer& ren)
1299         sbool_unite_shapes(sg1, sg2, sl1, sl2, sl, ren,
1319                                 Scanline& sl, Renderer& ren)
1324         sbool_unite_shapes(sg1, sg2, sl1, sl2, sl, ren,
1351                              Scanline& sl, Renderer& ren)
1357         sbool_unite_shapes(sg1, sg2, sl1, sl2, sl, ren,
1378                                     Scanline& sl, Renderer& ren)
1386         sbool_unite_shapes(sg1, sg2, sl1, sl2, sl, ren,
1406                                       Scanline& sl, Renderer& ren)
1414         sbool_unite_shapes(sg1, sg2, sl1, sl2, sl, ren,
1432                               Scanline& sl, Renderer& ren)
1437         sbool_unite_shapes(sg1, sg2, sl1, sl2, sl, ren,
1458                                   Scanline& sl, Renderer& ren)
1462         sbool_subtract_shapes(sg1, sg2, sl1, sl2, sl, ren,
1482                                    Scanline& sl, Renderer& ren)
1486         sbool_subtract_shapes(sg1, sg2, sl1, sl2, sl, ren,
1522                                   Scanline& sl, Renderer& ren)
1526         case sbool_or          : sbool_unite_shapes_bin    (sg1, sg2, sl1, sl2, sl, ren); break;
1527         case sbool_and         : sbool_intersect_shapes_bin(sg1, sg2, sl1, sl2, sl, ren); break;
1530         case sbool_xor_abs_diff: sbool_xor_shapes_bin      (sg1, sg2, sl1, sl2, sl, ren); break;
1531         case sbool_a_minus_b   : sbool_subtract_shapes_bin (sg1, sg2, sl1, sl2, sl, ren); break;
1532         case sbool_b_minus_a   : sbool_subtract_shapes_bin (sg2, sg1, sl2, sl1, sl, ren); break;
1549                                  Scanline& sl, Renderer& ren)
1553         case sbool_or          : sbool_unite_shapes_aa       (sg1, sg2, sl1, sl2, sl, ren); break;
1554         case sbool_and         : sbool_intersect_shapes_aa   (sg1, sg2, sl1, sl2, sl, ren); break;
1555         case sbool_xor         : sbool_xor_shapes_aa         (sg1, sg2, sl1, sl2, sl, ren); break;
1556         case sbool_xor_saddle  : sbool_xor_shapes_saddle_aa  (sg1, sg2, sl1, sl2, sl, ren); break;
1557         case sbool_xor_abs_diff: sbool_xor_shapes_abs_diff_aa(sg1, sg2, sl1, sl2, sl, ren); break;
1558         case sbool_a_minus_b   : sbool_subtract_shapes_aa    (sg1, sg2, sl1, sl2, sl, ren); break;
1559         case sbool_b_minus_a   : sbool_subtract_shapes_aa    (sg2, sg1, sl2, sl1, sl, ren); break;