Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit2c92c23

Browse files
committed
Shorten Agg template usage with class template argument deduction.
Many parts of the Agg & path processing pipeline work by constructingnested templated objects that represent steps of the processingpipeline, 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 aliastypenames for the types at each intermediate step.As of C++17, this can be made simpler and shorter because class templateargument 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 thoughthey are implemented as the construction of nested objects), it may feelmore 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 parent9f7b3dd commit2c92c23

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
inlinevoid
297297
RendererAgg::_draw_path(path_t &path,bool has_clippath,constfacepair_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_typepfa(pixFmt, alphaMask);
314-
amask_ren_typer(pfa);
315-
amask_aa_renderer_typeren(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_typepfa(pixFmt, alphaMask);
325-
amask_ren_typer(pfa);
326-
amask_bin_renderer_typeren(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::PathIteratorhatch_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_thatch_path_trans(hatch_path, hatch_trans);
355-
hatch_path_curve_thatch_path_curve(hatch_path_trans);
356-
hatch_path_stroke_thatch_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_typeimg_src(hatch_img_pixf);
386-
span_gen_typesg(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_typepfa(pixFmt, alphaMask);
391-
amask_ren_typeren(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_tstroke(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_tdash(path);
398+
auto dash = agg::conv_dash{path};
413399
gc.dashes.dash_to_stroke(dash, dpi, gc.isaa);
414-
stroke_dash_tstroke(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_typepfa(pixFmt, alphaMask);
425-
amask_ren_typer(pfa);
426-
amask_aa_renderer_typeren(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_typepfa(pixFmt, alphaMask);
436-
amask_ren_typer(pfa);
437-
amask_bin_renderer_typeren(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
inlinevoid
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_tface(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_ttpath(path, trans);
477-
nan_removed_tnan_removed(tpath,true, path.has_codes());
478-
clipped_tclipped(nan_removed, clip, width, height);
479-
snapped_tsnapped(clipped, gc.snap_mode, path.total_vertices(), snapping_linewidth);
480-
simplify_tsimplified(snapped, simplify, path.simplify_threshold());
481-
curve_tcurve(simplified);
482-
sketch_tsketch(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_tmarker_path_transformed(marker_path, marker_trans);
511-
nan_removed_tmarker_path_nan_removed(marker_path_transformed,true, marker_path.has_codes());
512-
snap_tmarker_path_snapped(marker_path_nan_removed,
513-
gc.snap_mode,
514-
marker_path.total_vertices(),
515-
points_to_pixels(gc.linewidth));
516-
curve_tmarker_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_tpath_transformed(path, trans);
526-
nan_removed_tpath_nan_removed(path_transformed,false,false);
527-
snap_tpath_snapped(path_nan_removed, SNAP_FALSE, path.total_vertices(),0.0);
528-
curve_tpath_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_tface(color.a !=0.0, color);
@@ -559,7 +531,7 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
559531
scanlines.max_y());
560532
}
561533

562-
stroke_tstroke(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_typepfa(pixFmt, alphaMask);
615-
amask_ren_typer(pfa);
616-
amask_aa_renderer_typeren(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<classImageArray>
722694
inlinevoidRendererAgg::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_typeinterpolator(inv_mtx);
764-
color_span_alloc_type sa;
765-
image_accessor_typeia(pixf_img,agg::gray8(0));
766-
image_span_gen_typeimage_span_generator(ia, interpolator, filter);
767-
span_gen_typeoutput_span_generator(&image_span_generator, gc.color);
768-
renderer_typeri(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_affineinv_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_typeia(pixf,agg::rgba8(0,0,0,0));
873-
interpolator_typeinterpolator(inv_mtx);
874-
image_span_gen_typeimage_span_generator(ia, interpolator);
875-
span_conv_alphaconv_alpha(alpha);
876-
span_convspans(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_typepfa(pixFmt, alphaMask);
884-
amask_ren_typer(pfa);
885-
renderer_type_alphari(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_ttpath(path, trans);
1009-
nan_removed_tnan_removed(tpath,true, has_codes);
1010-
clipped_tclipped(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_tsnapped(
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_tcurve(snapped);
1016-
sketch_snapped_curve_tsketch(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_tsketch(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_tcurve(clipped);
1025-
sketch_curve_tsketch(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_tsketch(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_typepfa(pixFmt, alphaMask);
1229-
amask_ren_typer(pfa);
1230-
amask_aa_renderer_typeren(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)
[8]ページ先頭
©2009-2025 Movatter.jp