Skip to content

Commit 2c92c23

Browse files
anntzeranntzer
committed
Shorten Agg template usage with class template argument deduction.
Many parts of the Agg & path processing pipeline work by constructing nested templated objects that represent steps of the processing pipeline, e.g. (simplified example) ``` agg::conv_transform<mpl::PathIterator> // The processing step. tpath // The name of the result. (path, trans); // The arguments passed to the processing step. PathNanRemover<agg::conv_transform<mpl::PathIterator>> nan_removed (tpath, true, path.has_codes()); ``` The current implementation makes the code shorter by introducing alias typenames for the types at each intermediate step. As of C++17, this can be made simpler and shorter because class template argument deduction ("CTAD") allows not specifying the template arguments (in angle brackets) anymore, i.e. one can write ``` agg::conv_transform tpath(path, trans); PathNanRemover nan_removed(tpath, true, path.has_codes()); ``` and the compiler will auto-fill in the required types. Furthermore, because these steps can be seen as a pipeline (even though they are implemented as the construction of nested objects), it may feel more natural to write them as repeated "function" (constructor) application, i.e. ``` auto tpath = agg::conv_transform{path, trans}; auto nan_removed = PathNanRemover{tpath, true, path.has_codes()}; ``` Perform this transformation whereever applicable.
1 parent 9f7b3dd commit 2c92c23

File tree

2 files changed

+125
-229
lines changed

2 files changed

+125
-229
lines changed

‎src/_backend_agg.h

Lines changed: 83 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -296,23 +296,15 @@ template <class path_t>
296296
inline void
297297
RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face, GCAgg &gc)
298298
{
299-
typedef agg::conv_stroke<path_t> stroke_t;
300-
typedef agg::conv_dash<path_t> dash_t;
301-
typedef agg::conv_stroke<dash_t> stroke_dash_t;
302-
typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
303-
typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
304-
typedef agg::renderer_scanline_aa_solid<amask_ren_type> amask_aa_renderer_type;
305-
typedef agg::renderer_scanline_bin_solid<amask_ren_type> amask_bin_renderer_type;
306-
307299
// Render face
308300
if (face.first) {
309301
theRasterizer.add_path(path);
310302

311303
if (gc.isaa) {
312304
if (has_clippath) {
313-
pixfmt_amask_type pfa(pixFmt, alphaMask);
314-
amask_ren_type r(pfa);
315-
amask_aa_renderer_type ren(r);
305+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
306+
auto r = agg::renderer_base{pfa};
307+
auto ren = agg::renderer_scanline_aa_solid{r};
316308
ren.color(face.second);
317309
agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);
318310
} else {
@@ -321,9 +313,9 @@ RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face,
321313
}
322314
} else {
323315
if (has_clippath) {
324-
pixfmt_amask_type pfa(pixFmt, alphaMask);
325-
amask_ren_type r(pfa);
326-
amask_bin_renderer_type ren(r);
316+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
317+
auto r = agg::renderer_base{pfa};
318+
auto ren = agg::renderer_scanline_bin_solid{r};
327319
ren.color(face.second);
328320
agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);
329321
} else {
@@ -341,19 +333,15 @@ RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face,
341333
rendererBase.reset_clipping(true);
342334

343335
// Create and transform the path
344-
typedef agg::conv_transform<mpl::PathIterator> hatch_path_trans_t;
345-
typedef agg::conv_curve<hatch_path_trans_t> hatch_path_curve_t;
346-
typedef agg::conv_stroke<hatch_path_curve_t> hatch_path_stroke_t;
347-
348336
mpl::PathIterator hatch_path(gc.hatchpath);
349337
agg::trans_affine hatch_trans;
350338
hatch_trans *= agg::trans_affine_scaling(1.0, -1.0);
351339
hatch_trans *= agg::trans_affine_translation(0.0, 1.0);
352340
hatch_trans *= agg::trans_affine_scaling(static_cast<double>(hatch_size),
353341
static_cast<double>(hatch_size));
354-
hatch_path_trans_t hatch_path_trans(hatch_path, hatch_trans);
355-
hatch_path_curve_t hatch_path_curve(hatch_path_trans);
356-
hatch_path_stroke_t hatch_path_stroke(hatch_path_curve);
342+
auto hatch_path_trans = agg::conv_transform{hatch_path, hatch_trans};
343+
auto hatch_path_curve = agg::conv_curve{hatch_path_trans};
344+
auto hatch_path_stroke = agg::conv_stroke{hatch_path_curve};
357345
hatch_path_stroke.width(points_to_pixels(gc.hatch_linewidth));
358346
hatch_path_stroke.line_cap(agg::square_cap);
359347

@@ -377,18 +365,16 @@ RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face,
377365
}
378366

379367
// Transfer the hatch to the main image buffer
380-
typedef agg::image_accessor_wrap<pixfmt,
381-
agg::wrap_mode_repeat_auto_pow2,
382-
agg::wrap_mode_repeat_auto_pow2> img_source_type;
383-
typedef agg::span_pattern_rgba<img_source_type> span_gen_type;
384368
agg::span_allocator<agg::rgba8> sa;
385-
img_source_type img_src(hatch_img_pixf);
386-
span_gen_type sg(img_src, 0, 0);
369+
auto img_src = agg::image_accessor_wrap<
370+
pixfmt, agg::wrap_mode_repeat_auto_pow2, agg::wrap_mode_repeat_auto_pow2>{
371+
hatch_img_pixf};
372+
auto sg = agg::span_pattern_rgba{img_src, 0, 0};
387373
theRasterizer.add_path(path);
388374

389375
if (has_clippath) {
390-
pixfmt_amask_type pfa(pixFmt, alphaMask);
391-
amask_ren_type ren(pfa);
376+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
377+
auto ren = agg::renderer_base{pfa};
392378
agg::render_scanlines_aa(theRasterizer, slineP8, ren, sa, sg);
393379
} else {
394380
agg::render_scanlines_aa(theRasterizer, slineP8, rendererBase, sa, sg);
@@ -402,16 +388,16 @@ RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face,
402388
linewidth = (linewidth < 0.5) ? 0.5 : mpl_round(linewidth);
403389
}
404390
if (gc.dashes.size() == 0) {
405-
stroke_t stroke(path);
391+
auto stroke = agg::conv_stroke{path};
406392
stroke.width(points_to_pixels(gc.linewidth));
407393
stroke.line_cap(gc.cap);
408394
stroke.line_join(gc.join);
409395
stroke.miter_limit(points_to_pixels(gc.linewidth));
410396
theRasterizer.add_path(stroke);
411397
} else {
412-
dash_t dash(path);
398+
auto dash = agg::conv_dash{path};
413399
gc.dashes.dash_to_stroke(dash, dpi, gc.isaa);
414-
stroke_dash_t stroke(dash);
400+
auto stroke = agg::conv_stroke{dash};
415401
stroke.line_cap(gc.cap);
416402
stroke.line_join(gc.join);
417403
stroke.width(linewidth);
@@ -421,9 +407,9 @@ RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face,
421407

422408
if (gc.isaa) {
423409
if (has_clippath) {
424-
pixfmt_amask_type pfa(pixFmt, alphaMask);
425-
amask_ren_type r(pfa);
426-
amask_aa_renderer_type ren(r);
410+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
411+
auto r = agg::renderer_base{pfa};
412+
auto ren = agg::renderer_scanline_aa_solid{r};
427413
ren.color(gc.color);
428414
agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);
429415
} else {
@@ -432,9 +418,9 @@ RendererAgg::_draw_path(path_t &path, bool has_clippath, const facepair_t &face,
432418
}
433419
} else {
434420
if (has_clippath) {
435-
pixfmt_amask_type pfa(pixFmt, alphaMask);
436-
amask_ren_type r(pfa);
437-
amask_bin_renderer_type ren(r);
421+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
422+
auto r = agg::renderer_base{pfa};
423+
auto ren = agg::renderer_scanline_bin_solid{r};
438424
ren.color(gc.color);
439425
agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);
440426
} else {
@@ -449,14 +435,6 @@ template <class PathIterator>
449435
inline void
450436
RendererAgg::draw_path(GCAgg &gc, PathIterator &path, agg::trans_affine &trans, agg::rgba &color)
451437
{
452-
typedef agg::conv_transform<mpl::PathIterator> transformed_path_t;
453-
typedef PathNanRemover<transformed_path_t> nan_removed_t;
454-
typedef PathClipper<nan_removed_t> clipped_t;
455-
typedef PathSnapper<clipped_t> snapped_t;
456-
typedef PathSimplifier<snapped_t> simplify_t;
457-
typedef agg::conv_curve<simplify_t> curve_t;
458-
typedef Sketch<curve_t> sketch_t;
459-
460438
facepair_t face(color.a != 0.0, color);
461439

462440
theRasterizer.reset_clipping();
@@ -473,13 +451,15 @@ RendererAgg::draw_path(GCAgg &gc, PathIterator &path, agg::trans_affine &trans,
473451
snapping_linewidth = 0.0;
474452
}
475453

476-
transformed_path_t tpath(path, trans);
477-
nan_removed_t nan_removed(tpath, true, path.has_codes());
478-
clipped_t clipped(nan_removed, clip, width, height);
479-
snapped_t snapped(clipped, gc.snap_mode, path.total_vertices(), snapping_linewidth);
480-
simplify_t simplified(snapped, simplify, path.simplify_threshold());
481-
curve_t curve(simplified);
482-
sketch_t sketch(curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);
454+
auto tpath = agg::conv_transform{path, trans};
455+
auto nan_removed = PathNanRemover{tpath, true, path.has_codes()};
456+
auto clipped = PathClipper(nan_removed, clip, width, height);
457+
auto snapped = PathSnapper{
458+
clipped, gc.snap_mode, path.total_vertices(), snapping_linewidth};
459+
auto simplified = PathSimplifier{snapped, simplify, path.simplify_threshold()};
460+
auto curve = agg::conv_curve{simplified};
461+
auto sketch = Sketch{
462+
curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness};
483463

484464
_draw_path(sketch, has_clippath, face, gc);
485465
}
@@ -492,28 +472,19 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
492472
agg::trans_affine &trans,
493473
agg::rgba color)
494474
{
495-
typedef agg::conv_transform<mpl::PathIterator> transformed_path_t;
496-
typedef PathNanRemover<transformed_path_t> nan_removed_t;
497-
typedef PathSnapper<nan_removed_t> snap_t;
498-
typedef agg::conv_curve<snap_t> curve_t;
499-
typedef agg::conv_stroke<curve_t> stroke_t;
500-
typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
501-
typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
502-
typedef agg::renderer_scanline_aa_solid<amask_ren_type> amask_aa_renderer_type;
503-
504475
// Deal with the difference in y-axis direction
505476
marker_trans *= agg::trans_affine_scaling(1.0, -1.0);
506477

507478
trans *= agg::trans_affine_scaling(1.0, -1.0);
508479
trans *= agg::trans_affine_translation(0.5, (double)height + 0.5);
509480

510-
transformed_path_t marker_path_transformed(marker_path, marker_trans);
511-
nan_removed_t marker_path_nan_removed(marker_path_transformed, true, marker_path.has_codes());
512-
snap_t marker_path_snapped(marker_path_nan_removed,
513-
gc.snap_mode,
514-
marker_path.total_vertices(),
515-
points_to_pixels(gc.linewidth));
516-
curve_t marker_path_curve(marker_path_snapped);
481+
auto marker_path_transformed = agg::conv_transform{marker_path, marker_trans};
482+
auto marker_path_nan_removed = PathNanRemover{
483+
marker_path_transformed, true, marker_path.has_codes()};
484+
auto marker_path_snapped = PathSnapper{
485+
marker_path_nan_removed,
486+
gc.snap_mode, marker_path.total_vertices(), points_to_pixels(gc.linewidth)};
487+
auto marker_path_curve = agg::conv_curve{marker_path_snapped};
517488

518489
if (!marker_path_snapped.is_snapping()) {
519490
// If the path snapper isn't in effect, at least make sure the marker
@@ -522,10 +493,11 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
522493
marker_trans *= agg::trans_affine_translation(0.5, 0.5);
523494
}
524495

525-
transformed_path_t path_transformed(path, trans);
526-
nan_removed_t path_nan_removed(path_transformed, false, false);
527-
snap_t path_snapped(path_nan_removed, SNAP_FALSE, path.total_vertices(), 0.0);
528-
curve_t path_curve(path_snapped);
496+
auto path_transformed = agg::conv_transform{path, trans};
497+
auto path_nan_removed = PathNanRemover{path_transformed, false, false};
498+
auto path_snapped = PathSnapper{
499+
path_nan_removed, SNAP_FALSE, path.total_vertices(), 0.0};
500+
auto path_curve = agg::conv_curve{path_snapped};
529501
path_curve.rewind(0);
530502

531503
facepair_t face(color.a != 0.0, color);
@@ -559,7 +531,7 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
559531
scanlines.max_y());
560532
}
561533

562-
stroke_t stroke(marker_path_curve);
534+
auto stroke = agg::conv_stroke{marker_path_curve};
563535
stroke.width(points_to_pixels(gc.linewidth));
564536
stroke.line_cap(gc.cap);
565537
stroke.line_join(gc.join);
@@ -611,9 +583,9 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
611583
continue;
612584
}
613585

614-
pixfmt_amask_type pfa(pixFmt, alphaMask);
615-
amask_ren_type r(pfa);
616-
amask_aa_renderer_type ren(r);
586+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
587+
auto r = agg::renderer_base{pfa};
588+
auto ren = agg::renderer_scanline_aa_solid{r};
617589

618590
if (face.first) {
619591
ren.color(face.second);
@@ -721,14 +693,6 @@ class font_to_rgba
721693
template <class ImageArray>
722694
inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, int y, double angle)
723695
{
724-
typedef agg::span_allocator<agg::rgba8> color_span_alloc_type;
725-
typedef agg::span_interpolator_linear<> interpolator_type;
726-
typedef agg::image_accessor_clip<agg::pixfmt_gray8> image_accessor_type;
727-
typedef agg::span_image_filter_gray<image_accessor_type, interpolator_type> image_span_gen_type;
728-
typedef font_to_rgba<image_span_gen_type> span_gen_type;
729-
typedef agg::renderer_scanline_aa<renderer_base, color_span_alloc_type, span_gen_type>
730-
renderer_type;
731-
732696
theRasterizer.reset_clipping();
733697
rendererBase.reset_clipping(true);
734698
if (angle != 0.0) {
@@ -760,12 +724,12 @@ inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, in
760724

761725
agg::image_filter_lut filter;
762726
filter.calculate(agg::image_filter_spline36());
763-
interpolator_type interpolator(inv_mtx);
764-
color_span_alloc_type sa;
765-
image_accessor_type ia(pixf_img, agg::gray8(0));
766-
image_span_gen_type image_span_generator(ia, interpolator, filter);
767-
span_gen_type output_span_generator(&image_span_generator, gc.color);
768-
renderer_type ri(rendererBase, sa, output_span_generator);
727+
auto interpolator = agg::span_interpolator_linear{inv_mtx};
728+
auto sa = agg::span_allocator<agg::rgba8>{};
729+
auto ia = agg::image_accessor_clip{pixf_img, agg::gray8(0)};
730+
auto image_span_generator = agg::span_image_filter_gray{ia, interpolator, filter};
731+
auto output_span_generator = font_to_rgba{&image_span_generator, gc.color};
732+
auto ri = agg::renderer_scanline_aa{rendererBase, sa, output_span_generator};
769733

770734
theRasterizer.add_path(rect2);
771735
agg::render_scanlines(theRasterizer, slineP8, ri);
@@ -861,28 +825,16 @@ inline void RendererAgg::draw_image(GCAgg &gc,
861825
agg::trans_affine inv_mtx(mtx);
862826
inv_mtx.invert();
863827

864-
typedef agg::span_allocator<agg::rgba8> color_span_alloc_type;
865-
typedef agg::image_accessor_clip<pixfmt> image_accessor_type;
866-
typedef agg::span_interpolator_linear<> interpolator_type;
867-
typedef agg::span_image_filter_rgba_nn<image_accessor_type, interpolator_type>
868-
image_span_gen_type;
869-
typedef agg::span_converter<image_span_gen_type, span_conv_alpha> span_conv;
870-
871-
color_span_alloc_type sa;
872-
image_accessor_type ia(pixf, agg::rgba8(0, 0, 0, 0));
873-
interpolator_type interpolator(inv_mtx);
874-
image_span_gen_type image_span_generator(ia, interpolator);
875-
span_conv_alpha conv_alpha(alpha);
876-
span_conv spans(image_span_generator, conv_alpha);
877-
878-
typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
879-
typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
880-
typedef agg::renderer_scanline_aa<amask_ren_type, color_span_alloc_type, span_conv>
881-
renderer_type_alpha;
882-
883-
pixfmt_amask_type pfa(pixFmt, alphaMask);
884-
amask_ren_type r(pfa);
885-
renderer_type_alpha ri(r, sa, spans);
828+
auto sa = agg::span_allocator<agg::rgba8>{};
829+
auto ia = agg::image_accessor_clip{pixf, agg::rgba8(0, 0, 0, 0)};
830+
auto interpolator = agg::span_interpolator_linear{inv_mtx};
831+
auto image_span_generator = agg::span_image_filter_rgba_nn{ia, interpolator};
832+
auto conv_alpha = span_conv_alpha{alpha};
833+
auto spans = agg::span_converter{image_span_generator, conv_alpha};
834+
835+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
836+
auto r = agg::renderer_base{pfa};
837+
auto ri = agg::renderer_scanline_aa{r, sa, spans};
886838

887839
theRasterizer.add_path(rect2);
888840
agg::render_scanlines(theRasterizer, scanlineAlphaMask, ri);
@@ -919,17 +871,6 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
919871
bool check_snap,
920872
bool has_codes)
921873
{
922-
typedef agg::conv_transform<typename PathGenerator::path_iterator> transformed_path_t;
923-
typedef PathNanRemover<transformed_path_t> nan_removed_t;
924-
typedef PathClipper<nan_removed_t> clipped_t;
925-
typedef PathSnapper<clipped_t> snapped_t;
926-
typedef agg::conv_curve<snapped_t> snapped_curve_t;
927-
typedef agg::conv_curve<clipped_t> curve_t;
928-
typedef Sketch<clipped_t> sketch_clipped_t;
929-
typedef Sketch<curve_t> sketch_curve_t;
930-
typedef Sketch<snapped_t> sketch_snapped_t;
931-
typedef Sketch<snapped_curve_t> sketch_snapped_curve_t;
932-
933874
size_t Npaths = path_generator.num_paths();
934875
size_t Noffsets = safe_first_shape(offsets);
935876
size_t N = std::max(Npaths, Noffsets);
@@ -1005,27 +946,31 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
1005946
}
1006947

1007948
gc.isaa = antialiaseds(i % Naa);
1008-
transformed_path_t tpath(path, trans);
1009-
nan_removed_t nan_removed(tpath, true, has_codes);
1010-
clipped_t clipped(nan_removed, do_clip, width, height);
949+
auto tpath = agg::conv_transform{path, trans};
950+
auto nan_removed = PathNanRemover{tpath, true, has_codes};
951+
auto clipped = PathClipper(nan_removed, do_clip, width, height);
1011952
if (check_snap) {
1012-
snapped_t snapped(
1013-
clipped, gc.snap_mode, path.total_vertices(), points_to_pixels(gc.linewidth));
953+
auto snapped = PathSnapper{
954+
clipped, gc.snap_mode, path.total_vertices(), points_to_pixels(gc.linewidth)};
1014955
if (has_codes) {
1015-
snapped_curve_t curve(snapped);
1016-
sketch_snapped_curve_t sketch(curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);
956+
auto curve = agg::conv_curve{snapped};
957+
auto sketch = Sketch{
958+
curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness};
1017959
_draw_path(sketch, has_clippath, face, gc);
1018960
} else {
1019-
sketch_snapped_t sketch(snapped, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);
961+
auto sketch = Sketch{
962+
snapped, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness};
1020963
_draw_path(sketch, has_clippath, face, gc);
1021964
}
1022965
} else {
1023966
if (has_codes) {
1024-
curve_t curve(clipped);
1025-
sketch_curve_t sketch(curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);
967+
auto curve = agg::conv_curve{clipped};
968+
auto sketch = Sketch{
969+
curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness};
1026970
_draw_path(sketch, has_clippath, face, gc);
1027971
} else {
1028-
sketch_clipped_t sketch(clipped, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);
972+
auto sketch = Sketch{
973+
clipped, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness};
1029974
_draw_path(sketch, has_clippath, face, gc);
1030975
}
1031976
}
@@ -1220,14 +1165,9 @@ inline void RendererAgg::_draw_gouraud_triangle(PointArray &points,
12201165
theRasterizer.add_path(span_gen);
12211166

12221167
if (has_clippath) {
1223-
typedef agg::pixfmt_amask_adaptor<pixfmt, alpha_mask_type> pixfmt_amask_type;
1224-
typedef agg::renderer_base<pixfmt_amask_type> amask_ren_type;
1225-
typedef agg::renderer_scanline_aa<amask_ren_type, span_alloc_t, span_gen_t>
1226-
amask_aa_renderer_type;
1227-
1228-
pixfmt_amask_type pfa(pixFmt, alphaMask);
1229-
amask_ren_type r(pfa);
1230-
amask_aa_renderer_type ren(r, span_alloc, span_gen);
1168+
auto pfa = agg::pixfmt_amask_adaptor{pixFmt, alphaMask};
1169+
auto r = agg::renderer_base{pfa};
1170+
auto ren = agg::renderer_scanline_aa{r, span_alloc, span_gen};
12311171
agg::render_scanlines(theRasterizer, scanlineAlphaMask, ren);
12321172
} else {
12331173
agg::render_scanlines_aa(theRasterizer, slineP8, rendererBase, span_alloc, span_gen);

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy