using pixfmt_pre_type = std::conditional_t<

is_grayscale_v<color_type>,

pixfmt_type,

agg::pixfmt_alpha_blend_rgba<

std::conditional_t<

std::is_same_v<color_type, agg::rgba8>,

fixed_blender_rgba_pre<color_type, agg::order_rgba>,

agg::blender_rgba_pre<color_type, agg::order_rgba>

>,

agg::rendering_buffer>

>;

template<class ColorT, class Order>

struct fixed_blender_rgba_pre : agg::conv_rgba_pre<ColorT, Order>

{

typedef ColorT 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;

enum base_scale_e

{

base_shift = color_type::base_shift,

base_mask = color_type::base_mask

};

//--------------------------------------------------------------------

static AGG_INLINE void blend_pix(value_type* p,

value_type cr, value_type cg, value_type cb,

value_type alpha, agg::cover_type cover)

{

blend_pix(p,

color_type::mult_cover(cr, cover),

color_type::mult_cover(cg, cover),

color_type::mult_cover(cb, cover),

color_type::mult_cover(alpha, cover));

}

//--------------------------------------------------------------------

static AGG_INLINE void blend_pix(value_type* p,

value_type cr, value_type cg, value_type cb,

value_type alpha)

{

alpha = base_mask - alpha;

p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);

p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);

p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);

p[Order::A] = (value_type)(base_mask - ((alpha * (base_mask - p[Order::A])) >> base_shift));

}

};