Skip to content

Add blend modes and blend groups for compositing #31162

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
story645 merged 10 commits into from
Aug 27, 2026
Merged

Add blend modes and blend groups for compositing #31162

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
5ad8cab
Add support for specifying the blend mode for an artist
ayshih Feb 15, 2026
9199535
Add Agg code for computing HSL blend modes
ayshih Feb 17, 2026
aebc329
Add support for blend modes in non-PS backends
ayshih May 5, 2026
2ccbbd3
Fix precision loss with Agg compositing
ayshih Feb 17, 2026
22091f7
Add support for Gouraud shading in Cairo-based backends
ayshih Feb 20, 2026
7301134
Fix ability to specify scalar alpha to Agg draw_image
ayshih Mar 4, 2026
ced4c64
Add support for blend groups (aka transparency groups)
ayshih May 5, 2026
fcef182
Add documentation pages and whatsnew entry
ayshih Feb 19, 2026
8c0fee9
Fix Agg rendering of Gouraud shading
ayshih Mar 4, 2026
a848ba4
Add image tests for blend modes and blend groups
ayshih May 6, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Fix precision loss with Agg compositing
  • Loading branch information
@ayshih
ayshih committed Aug 26, 2026
commit 2ccbbd3a81185a77987cbe78471d05dfb2ac8838
2 changes: 1 addition & 1 deletion src/_backend_agg.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,7 +109,7 @@ class RendererAgg
{
public:

typedef agg::comp_op_adaptor_rgba_plain<agg::rgba8, agg::order_rgba> comp_op_blender_plain;
typedef fixed_comp_op_adaptor_rgba8_plain<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;
Expand Down
63 changes: 62 additions & 1 deletion src/agg_workaround.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@

/**********************************************************************
WORKAROUND: This class is to workaround a bug in Agg SVN where the
blending of RGBA32 pixels does not preserve enough precision
blending of RGBA8 pixels does not preserve enough precision
*/

template<class ColorT, class Order>
Expand All @@ -31,6 +31,9 @@ struct fixed_blender_rgba_plain : agg::conv_rgba_plain<ColorT, Order>
value_type cr, value_type cg, value_type cb, value_type alpha)
{
if(alpha == 0) return;

// The following code does not accurately transform to higher bit depth
// TODO: Improve the accuracy of this code when we are prepared to regenerate all baseline images
Comment thread
story645 marked this conversation as resolved.
calc_type a = p[Order::A];
calc_type r = p[Order::R] * a;
calc_type g = p[Order::G] * a;
Expand All @@ -44,6 +47,64 @@ struct fixed_blender_rgba_plain : agg::conv_rgba_plain<ColorT, Order>
};


/**********************************************************************
WORKAROUND: As above, this class is to workaround a bug in Agg where
the plain->plain blending of RGBA8 pixels is forced back to 8-bit
values between steps, which degrades the calculation. This class
supports compositing operators (aka blend modes), and falls back to
the above class for normal alpha blending.
*/

template<class Order>
struct fixed_comp_op_adaptor_rgba8_plain
{
typedef agg::rgba8 color_type;
typedef Order order_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
typedef typename color_type::long_type long_type;

static AGG_INLINE void blend_pix(unsigned op, value_type* p,
value_type r, value_type g, value_type b, value_type a, agg::cover_type cover)
{
if(op == agg::comp_op_src_over)
{
// This operator is simply normal alpha blending, so fall back to the above class
// We need to special-case fully opaque to maintain past behavior
if(a == 255 && cover == agg::cover_full) {
p[Order::A] = a;
p[Order::R] = r;
p[Order::G] = g;
p[Order::B] = b;
return;
}
fixed_blender_rgba_plain<agg::rgba8, Order>::blend_pix(p, r, g, b, a, cover);
}
else
{
if(a == 0 || cover == 0) return;

// Convert to RGBA32 (floats) and premultiply
float d[4];
for(int i = 0; i < 4; i++) d[i] = agg::rgba8::to_double(p[i]);
agg::multiplier_rgba<agg::rgba32, Order>::premultiply(d);

double sa = agg::rgba8::to_double(a);
double sr = agg::rgba8::to_double(r) * sa;
double sg = agg::rgba8::to_double(g) * sa;
double sb = agg::rgba8::to_double(b) * sa;

// Blend as floats (internally, doubles)
agg::comp_op_table_rgba<agg::rgba32, Order>::g_comp_op_func[op](d, sr, sg, sb, sa, cover);

// Demultiply and return to RGBA8 space
agg::multiplier_rgba<agg::rgba32, Order>::demultiply(d);
for(int i = 0; i < 4; i++) p[i] = agg::rgba8::from_double(d[i]);
}
}
};


/**********************************************************************
This class provides higher-accuracy nearest-neighbor interpolation for
affine transforms than span_interpolator_linear by using
Expand Down