/**
* Performs blending of src and dst pixels
*
* @param blend the blend state of the shader variant
* @param cbuf_format format of the colour buffer
* @param type data type of the pixel vector
* @param rt rt number
* @param src blend src
* @param dst blend dst
* @param mask optional mask to apply to the blending result
* @param const_ const blend color
* @param swizzle swizzle values for RGBA
*
* @return the result of blending src and dst
*/
LLVMValueRef
lp_build_blend_aos(struct gallivm_state *gallivm,
const struct pipe_blend_state *blend,
const enum pipe_format *cbuf_format,
struct lp_type type,
unsigned rt,
LLVMValueRef src,
LLVMValueRef dst,
LLVMValueRef mask,
LLVMValueRef const_,
const unsigned char swizzle[4])
{
const struct pipe_rt_blend_state * state = &blend->rt[rt];
struct lp_build_blend_aos_context bld;
LLVMValueRef src_factor, dst_factor;
LLVMValueRef result;
unsigned alpha_swizzle = swizzle[3];
boolean fullcolormask;
/* Setup build context */
memset(&bld, 0, sizeof bld);
lp_build_context_init(&bld.base, gallivm, type);
bld.src = src;
bld.dst = dst;
bld.const_ = const_;
if (swizzle[3] > UTIL_FORMAT_SWIZZLE_W || swizzle[3] == swizzle[0])
alpha_swizzle = UTIL_FORMAT_SWIZZLE_NONE;
if (!state->blend_enable) {
result = src;
} else {
boolean rgb_alpha_same = state->rgb_src_factor == state->rgb_dst_factor && state->alpha_src_factor == state->alpha_dst_factor;
assert(rgb_alpha_same || alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE);
src_factor = lp_build_blend_factor(&bld, state->rgb_src_factor,
state->alpha_src_factor, alpha_swizzle);
dst_factor = lp_build_blend_factor(&bld, state->rgb_dst_factor,
state->alpha_dst_factor, alpha_swizzle);
result = lp_build_blend(&bld.base,
state->rgb_func,
state->rgb_src_factor,
state->rgb_dst_factor,
src,
dst,
src_factor,
dst_factor,
rgb_alpha_same,
false);
if(state->rgb_func != state->alpha_func && alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE) {
LLVMValueRef alpha;
alpha = lp_build_blend(&bld.base,
state->alpha_func,
state->alpha_src_factor,
state->alpha_dst_factor,
src,
dst,
src_factor,
dst_factor,
rgb_alpha_same,
false);
result = lp_build_blend_swizzle(&bld,
result,
alpha,
LP_BUILD_BLEND_SWIZZLE_RGBA,
alpha_swizzle);
}
}
/* Check if color mask is necessary */
fullcolormask = util_format_colormask_full(util_format_description(cbuf_format[rt]), state->colormask);
if (!fullcolormask) {
LLVMValueRef color_mask;
color_mask = lp_build_const_mask_aos_swizzled(gallivm, bld.base.type, state->colormask, swizzle);
lp_build_name(color_mask, "color_mask");
/* Combine with input mask if necessary */
if (mask) {
mask = lp_build_and(&bld.base, color_mask, mask);
} else {
mask = color_mask;
}
}
/* Apply mask, if one exists */
if (mask) {
result = lp_build_select(&bld.base, mask, result, dst);
}
return result;
}
/**
* Performs blending of src and dst pixels
*
* @param blend the blend state of the shader variant
* @param cbuf_format format of the colour buffer
* @param type data type of the pixel vector
* @param rt render target index
* @param src blend src
* @param src_alpha blend src alpha (if not included in src)
* @param src1 second blend src (for dual source blend)
* @param src1_alpha second blend src alpha (if not included in src1)
* @param dst blend dst
* @param mask optional mask to apply to the blending result
* @param const_ const blend color
* @param const_alpha const blend color alpha (if not included in const_)
* @param swizzle swizzle values for RGBA
*
* @return the result of blending src and dst
*/
LLVMValueRef
lp_build_blend_aos(struct gallivm_state *gallivm,
const struct pipe_blend_state *blend,
enum pipe_format cbuf_format,
struct lp_type type,
unsigned rt,
LLVMValueRef src,
LLVMValueRef src_alpha,
LLVMValueRef src1,
LLVMValueRef src1_alpha,
LLVMValueRef dst,
LLVMValueRef mask,
LLVMValueRef const_,
LLVMValueRef const_alpha,
const unsigned char swizzle[4],
int nr_channels)
{
const struct pipe_rt_blend_state * state = &blend->rt[rt];
const struct util_format_description * desc;
struct lp_build_blend_aos_context bld;
LLVMValueRef src_factor, dst_factor;
LLVMValueRef result;
unsigned alpha_swizzle = UTIL_FORMAT_SWIZZLE_NONE;
unsigned i;
desc = util_format_description(cbuf_format);
/* Setup build context */
memset(&bld, 0, sizeof bld);
lp_build_context_init(&bld.base, gallivm, type);
bld.src = src;
bld.src1 = src1;
bld.dst = dst;
bld.const_ = const_;
bld.src_alpha = src_alpha;
bld.src1_alpha = src1_alpha;
bld.const_alpha = const_alpha;
/* Find the alpha channel if not provided seperately */
if (!src_alpha) {
for (i = 0; i < 4; ++i) {
if (swizzle[i] == 3) {
alpha_swizzle = i;
}
}
}
if (blend->logicop_enable) {
if(!type.floating) {
result = lp_build_logicop(gallivm->builder, blend->logicop_func, src, dst);
}
else {
result = src;
}
} else if (!state->blend_enable) {
result = src;
} else {
boolean rgb_alpha_same = (state->rgb_src_factor == state->rgb_dst_factor && state->alpha_src_factor == state->alpha_dst_factor) || nr_channels == 1;
src_factor = lp_build_blend_factor(&bld, state->rgb_src_factor,
state->alpha_src_factor,
alpha_swizzle,
nr_channels);
dst_factor = lp_build_blend_factor(&bld, state->rgb_dst_factor,
state->alpha_dst_factor,
alpha_swizzle,
nr_channels);
result = lp_build_blend(&bld.base,
state->rgb_func,
state->rgb_src_factor,
state->rgb_dst_factor,
src,
dst,
src_factor,
dst_factor,
rgb_alpha_same,
false);
if(state->rgb_func != state->alpha_func && nr_channels > 1 && alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE) {
LLVMValueRef alpha;
alpha = lp_build_blend(&bld.base,
state->alpha_func,
state->alpha_src_factor,
state->alpha_dst_factor,
src,
dst,
src_factor,
dst_factor,
rgb_alpha_same,
false);
result = lp_build_blend_swizzle(&bld,
result,
alpha,
LP_BUILD_BLEND_SWIZZLE_RGBA,
alpha_swizzle,
nr_channels);
}
}
/* Check if color mask is necessary */
if (!util_format_colormask_full(desc, state->colormask)) {
LLVMValueRef color_mask;
color_mask = lp_build_const_mask_aos_swizzled(gallivm, bld.base.type, state->colormask, nr_channels, swizzle);
lp_build_name(color_mask, "color_mask");
/* Combine with input mask if necessary */
if (mask) {
/* We can be blending floating values but masks are always integer... */
unsigned floating = bld.base.type.floating;
bld.base.type.floating = 0;
mask = lp_build_and(&bld.base, color_mask, mask);
bld.base.type.floating = floating;
} else {
mask = color_mask;
}
}
/* Apply mask, if one exists */
if (mask) {
result = lp_build_select(&bld.base, mask, result, dst);
}
return result;
}
