WIP: Add support for blend modes in Agg backend

ayshih · ayshih · commit dee65fa7e65e · 2026-02-15T01:41:10.000-05:00
diff --git a/src/_backend_agg.h b/src/_backend_agg.h
@@ -109,8 +109,8 @@ class RendererAgg
 {
   public:
 
-    typedef fixed_blender_rgba_plain<agg::rgba8, agg::order_rgba> fixed_blender_rgba32_plain;
-    typedef agg::pixfmt_alpha_blend_rgba<fixed_blender_rgba32_plain, agg::rendering_buffer> pixfmt;
+    typedef agg::comp_op_adaptor_rgba_plain<agg::rgba8, agg::order_rgba> comp_op_blender_plain;
+    typedef agg::pixfmt_custom_blend_rgba<comp_op_blender_plain, agg::rendering_buffer> pixfmt;
     typedef agg::renderer_base<pixfmt> renderer_base;
     typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_aa;
     typedef agg::renderer_scanline_bin_solid<renderer_base> renderer_bin;
@@ -461,6 +461,8 @@ RendererAgg::draw_path(GCAgg &gc, PathIterator &path, agg::trans_affine &trans,
         face = color;
     }
 
+    pixFmt.comp_op(gc.comp_op);
+
     theRasterizer.reset_clipping();
     rendererBase.reset_clipping(true);
     set_clipbox(gc.cliprect, theRasterizer);
@@ -484,6 +486,8 @@ RendererAgg::draw_path(GCAgg &gc, PathIterator &path, agg::trans_affine &trans,
     sketch_t sketch(curve, gc.sketch.scale, gc.sketch.length, gc.sketch.randomness);
 
     _draw_path(sketch, has_clippath, face, gc);
+
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 template <class PathIterator>
@@ -571,6 +575,9 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
                                   std::max(marker_size.x2, scanlines.max_x()),
                                   std::max(marker_size.y2, scanlines.max_y()));
 
+
+        pixFmt.comp_op(gc.comp_op);
+
         theRasterizer.reset_clipping();
         rendererBase.reset_clipping(true);
         set_clipbox(gc.cliprect, rendererBase);
@@ -658,6 +665,8 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
 
     theRasterizer.reset_clipping();
     rendererBase.reset_clipping(true);
+
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 /**
@@ -714,6 +723,8 @@ inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, in
     typedef agg::renderer_scanline_aa<renderer_base, color_span_alloc_type, span_gen_type>
     renderer_type;
 
+    pixFmt.comp_op(gc.comp_op);
+
     theRasterizer.reset_clipping();
     rendererBase.reset_clipping(true);
     if (angle != 0.0) {
@@ -782,6 +793,8 @@ inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, in
             }
         }
     }
+
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 class span_conv_alpha
@@ -814,6 +827,7 @@ inline void RendererAgg::draw_image(GCAgg &gc,
                                     ImageArray &image)
 {
     double alpha = gc.alpha;
+    pixFmt.comp_op(gc.comp_op);
 
     theRasterizer.reset_clipping();
     rendererBase.reset_clipping(true);
@@ -878,6 +892,8 @@ inline void RendererAgg::draw_image(GCAgg &gc,
     }
 
     rendererBase.reset_clipping(true);
+
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 template <class PathIterator,
@@ -1042,6 +1058,7 @@ inline void RendererAgg::draw_path_collection(GCAgg &gc,
                                               AntialiasedArray &antialiaseds,
                                               ColorArray &hatchcolors)
 {
+    pixFmt.comp_op(gc.comp_op);
     _draw_path_collection_generic(gc,
                                   master_transform,
                                   gc.cliprect,
@@ -1059,6 +1076,7 @@ inline void RendererAgg::draw_path_collection(GCAgg &gc,
                                   true,
                                   true,
                                   hatchcolors);
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 template <class CoordinateArray>
@@ -1154,6 +1172,7 @@ inline void RendererAgg::draw_quad_mesh(GCAgg &gc,
     DashesVector linestyles;
     ColorArray hatchcolors = py::array_t<double>().reshape({0, 4}).unchecked<double, 2>();
 
+    pixFmt.comp_op(gc.comp_op);
     _draw_path_collection_generic(gc,
                                   master_transform,
                                   gc.cliprect,
@@ -1171,6 +1190,7 @@ inline void RendererAgg::draw_quad_mesh(GCAgg &gc,
                                   true, // check_snap
                                   false,
                                   hatchcolors);
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 template <class PointArray, class ColorArray>
@@ -1248,6 +1268,8 @@ inline void RendererAgg::draw_gouraud_triangles(GCAgg &gc,
             std::to_string(colors.shape(0)) + "colors");
     }
 
+    pixFmt.comp_op(gc.comp_op);
+
     theRasterizer.reset_clipping();
     rendererBase.reset_clipping(true);
     set_clipbox(gc.cliprect, theRasterizer);
@@ -1259,6 +1281,8 @@ inline void RendererAgg::draw_gouraud_triangles(GCAgg &gc,
 
         _draw_gouraud_triangle(point, color, trans, has_clippath);
     }
+
+    pixFmt.comp_op(agg::comp_op_src_over);
 }
 
 template <class R>
diff --git a/src/_backend_agg_basic_types.h b/src/_backend_agg_basic_types.h
@@ -11,6 +11,7 @@
 
 #include "agg_color_rgba.h"
 #include "agg_math_stroke.h"
+#include "agg_pixfmt_rgba.h"
 #include "agg_trans_affine.h"
 #include "path_converters.h"
 
@@ -80,6 +81,7 @@ class GCAgg
     GCAgg()
         : linewidth(1.0),
           alpha(1.0),
+          comp_op(agg::comp_op_src_over),
           cap(agg::butt_cap),
           join(agg::round_join),
           snap_mode(SNAP_FALSE)
@@ -93,6 +95,7 @@ class GCAgg
     double linewidth;
     double alpha;
     bool forced_alpha;
+    agg::comp_op_e comp_op;
     agg::rgba color;
     bool isaa;
 
@@ -125,6 +128,42 @@ class GCAgg
 };
 
 namespace PYBIND11_NAMESPACE { namespace detail {
+    template <> struct type_caster<agg::comp_op_e> {
+    public:
+        PYBIND11_TYPE_CASTER(agg::comp_op_e, const_name("comp_op_e"));
+
+        bool load(handle src, bool) {
+            const std::unordered_map<std::string, agg::comp_op_e> enum_values = {
+                {"clear", agg::comp_op_clear},
+                {"source", agg::comp_op_src},
+                //{"dest", agg::comp_op_dst},
+                {"over", agg::comp_op_src_over},
+                //{"dst_over", agg::comp_op_dst_over},
+                {"in", agg::comp_op_src_in},
+                //{"dst_in", agg::comp_op_dst_in},
+                {"out", agg::comp_op_src_out},
+                //{"dst_out", agg::comp_op_dst_out},
+                {"atop", agg::comp_op_src_atop},
+                //{"dst_atop", agg::comp_op_dst_atop},
+                {"xor", agg::comp_op_xor},
+                {"plus", agg::comp_op_plus},
+                {"multiply", agg::comp_op_multiply},
+                {"screen", agg::comp_op_screen},
+                {"overlay", agg::comp_op_overlay},
+                {"darken", agg::comp_op_darken},
+                {"lighten", agg::comp_op_lighten},
+                {"color_dodge", agg::comp_op_color_dodge},
+                {"color_burn", agg::comp_op_color_burn},
+                {"hard_light", agg::comp_op_hard_light},
+                {"soft_light", agg::comp_op_soft_light},
+                {"difference", agg::comp_op_difference},
+                {"exclusion", agg::comp_op_exclusion},
+            };
+            value = enum_values.at(src.cast<std::string>());
+            return true;
+        }
+    };
+
     template <> struct type_caster<agg::line_cap_e> {
     public:
         PYBIND11_TYPE_CASTER(agg::line_cap_e, const_name("line_cap_e"));
@@ -234,6 +273,7 @@ namespace PYBIND11_NAMESPACE { namespace detail {
             value.linewidth = src.attr("_linewidth").cast<double>();
             value.alpha = src.attr("_alpha").cast<double>();
             value.forced_alpha = src.attr("_forced_alpha").cast<bool>();
+            value.comp_op = src.attr("_blend_mode").cast<agg::comp_op_e>();
             value.color = src.attr("_rgb").cast<agg::rgba>();
             value.isaa = src.attr("_antialiased").cast<bool>();
             value.cap = src.attr("_capstyle").cast<agg::line_cap_e>();
