/**************************************************************************
*
* Copyright 2009 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
/**
* @file
* Blend LLVM IR generation -- AoS layout.
*
* AoS blending is in general much slower than SoA, but there are some cases
* where it might be faster. In particular, if a pixel is rendered only once
* then the overhead of tiling and untiling will dominate over the speedup that
* SoA gives. So we might want to detect such cases and fallback to AoS in the
* future, but for now this function is here for historical/benchmarking
* purposes.
*
* Run lp_blend_test after any change to this file.
*
* @author Jose Fonseca <jfonseca@vmware.com>
*/
#include "pipe/p_state.h"
#include "util/u_debug.h"
#include "util/u_format.h"
#include "gallivm/lp_bld_type.h"
#include "gallivm/lp_bld_const.h"
#include "gallivm/lp_bld_arit.h"
#include "gallivm/lp_bld_logic.h"
#include "gallivm/lp_bld_swizzle.h"
#include "gallivm/lp_bld_bitarit.h"
#include "gallivm/lp_bld_debug.h"
#include "lp_bld_blend.h"
/**
* We may the same values several times, so we keep them here to avoid
* recomputing them. Also reusing the values allows us to do simplifications
* that LLVM optimization passes wouldn't normally be able to do.
*/
struct lp_build_blend_aos_context
{
struct lp_build_context base;
LLVMValueRef src;
LLVMValueRef dst;
LLVMValueRef const_;
LLVMValueRef inv_src;
LLVMValueRef inv_dst;
LLVMValueRef inv_const;
LLVMValueRef saturate;
LLVMValueRef rgb_src_factor;
LLVMValueRef alpha_src_factor;
LLVMValueRef rgb_dst_factor;
LLVMValueRef alpha_dst_factor;
};
static LLVMValueRef
lp_build_blend_factor_unswizzled(struct lp_build_blend_aos_context *bld,
unsigned factor,
boolean alpha)
{
switch (factor) {
case PIPE_BLENDFACTOR_ZERO:
return bld->base.zero;
case PIPE_BLENDFACTOR_ONE:
return bld->base.one;
case PIPE_BLENDFACTOR_SRC_COLOR:
case PIPE_BLENDFACTOR_SRC_ALPHA:
return bld->src;
case PIPE_BLENDFACTOR_DST_COLOR:
case PIPE_BLENDFACTOR_DST_ALPHA:
return bld->dst;
case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
if(alpha)
return bld->base.one;
else {
if(!bld->inv_dst)
bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
if(!bld->saturate)
bld->saturate = lp_build_min(&bld->base, bld->src, bld->inv_dst);
return bld->saturate;
}
case PIPE_BLENDFACTOR_CONST_COLOR:
case PIPE_BLENDFACTOR_CONST_ALPHA:
return bld->const_;
case PIPE_BLENDFACTOR_SRC1_COLOR:
case PIPE_BLENDFACTOR_SRC1_ALPHA:
/* TODO */
assert(0);
return bld->base.zero;
case PIPE_BLENDFACTOR_INV_SRC_COLOR:
case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
if(!bld->inv_src)
bld->inv_src = lp_build_comp(&bld->base, bld->src);
return bld->inv_src;
case PIPE_BLENDFACTOR_INV_DST_COLOR:
case PIPE_BLENDFACTOR_INV_DST_ALPHA:
if(!bld->inv_dst)
bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
return bld->inv_dst;
case PIPE_BLENDFACTOR_INV_CONST_COLOR:
case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
if(!bld->inv_const)
bld->inv_const = lp_build_comp(&bld->base, bld->const_);
return bld->inv_const;
case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
/* TODO */
assert(0);
return bld->base.zero;
default:
assert(0);
return bld->base.zero;
}
}
enum lp_build_blend_swizzle {
LP_BUILD_BLEND_SWIZZLE_RGBA = 0,
LP_BUILD_BLEND_SWIZZLE_AAAA = 1
};
/**
* How should we shuffle the base factor.
*/
static enum lp_build_blend_swizzle
lp_build_blend_factor_swizzle(unsigned factor)
{
switch (factor) {
case PIPE_BLENDFACTOR_ONE:
case PIPE_BLENDFACTOR_ZERO:
case PIPE_BLENDFACTOR_SRC_COLOR:
case PIPE_BLENDFACTOR_DST_COLOR:
case PIPE_BLENDFACTOR_CONST_COLOR:
case PIPE_BLENDFACTOR_SRC1_COLOR:
case PIPE_BLENDFACTOR_INV_SRC_COLOR:
case PIPE_BLENDFACTOR_INV_DST_COLOR:
case PIPE_BLENDFACTOR_INV_CONST_COLOR:
case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
return LP_BUILD_BLEND_SWIZZLE_RGBA;
case PIPE_BLENDFACTOR_SRC_ALPHA:
case PIPE_BLENDFACTOR_DST_ALPHA:
case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
case PIPE_BLENDFACTOR_SRC1_ALPHA:
case PIPE_BLENDFACTOR_CONST_ALPHA:
case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
case PIPE_BLENDFACTOR_INV_DST_ALPHA:
case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
return LP_BUILD_BLEND_SWIZZLE_AAAA;
default:
assert(0);
return LP_BUILD_BLEND_SWIZZLE_RGBA;
}
}
static LLVMValueRef
lp_build_blend_swizzle(struct lp_build_blend_aos_context *bld,
LLVMValueRef rgb,
LLVMValueRef alpha,
enum lp_build_blend_swizzle rgb_swizzle,
unsigned alpha_swizzle)
{
LLVMValueRef swizzled_rgb;
switch (rgb_swizzle) {
case LP_BUILD_BLEND_SWIZZLE_RGBA:
swizzled_rgb = rgb;
break;
case LP_BUILD_BLEND_SWIZZLE_AAAA:
swizzled_rgb = lp_build_swizzle_scalar_aos(&bld->base, rgb, alpha_swizzle);
break;
default:
assert(0);
swizzled_rgb = bld->base.undef;
}
if (rgb != alpha) {
swizzled_rgb = lp_build_select_aos(&bld->base, 1 << alpha_swizzle,
alpha, swizzled_rgb);
}
return swizzled_rgb;
}
/**
* @sa http://www.opengl.org/sdk/docs/man/xhtml/glBlendFuncSeparate.xml
*/
static LLVMValueRef
lp_build_blend_factor(struct lp_build_blend_aos_context *bld,
unsigned rgb_factor,
unsigned alpha_factor,
unsigned alpha_swizzle)
{
LLVMValueRef rgb_factor_, alpha_factor_;
enum lp_build_blend_swizzle rgb_swizzle;
rgb_factor_ = lp_build_blend_factor_unswizzled(bld, rgb_factor, FALSE);
if (alpha_swizzle != UTIL_FORMAT_SWIZZLE_NONE) {
rgb_swizzle = lp_build_blend_factor_swizzle(rgb_factor);
alpha_factor_ = lp_build_blend_factor_unswizzled(bld, alpha_factor, TRUE);
return lp_build_blend_swizzle(bld, rgb_factor_, alpha_factor_, rgb_swizzle, alpha_swizzle);
} else {
return rgb_factor_;
}
}
/**
* 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;
}