/**************************************************************************
|
*
|
* 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 src_alpha;
|
LLVMValueRef src1;
|
LLVMValueRef src1_alpha;
|
LLVMValueRef dst;
|
LLVMValueRef const_;
|
LLVMValueRef const_alpha;
|
boolean has_dst_alpha;
|
|
LLVMValueRef inv_src;
|
LLVMValueRef inv_src_alpha;
|
LLVMValueRef inv_dst;
|
LLVMValueRef inv_const;
|
LLVMValueRef inv_const_alpha;
|
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)
|
{
|
LLVMValueRef src_alpha = bld->src_alpha ? bld->src_alpha : bld->src;
|
LLVMValueRef src1_alpha = bld->src1_alpha ? bld->src1_alpha : bld->src1;
|
LLVMValueRef const_alpha = bld->const_alpha ? bld->const_alpha : bld->const_;
|
|
switch (factor) {
|
case PIPE_BLENDFACTOR_ZERO:
|
return bld->base.zero;
|
case PIPE_BLENDFACTOR_ONE:
|
return bld->base.one;
|
case PIPE_BLENDFACTOR_SRC_COLOR:
|
return bld->src;
|
case PIPE_BLENDFACTOR_SRC_ALPHA:
|
return src_alpha;
|
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 there's no dst alpha the complement is zero but for unclamped
|
* float inputs (or snorm inputs) min can be non-zero (negative).
|
*/
|
if (!bld->saturate) {
|
if (!bld->has_dst_alpha) {
|
bld->saturate = lp_build_min(&bld->base, src_alpha, bld->base.zero);
|
}
|
else if (bld->base.type.norm && bld->base.type.sign) {
|
/*
|
* The complement/min totally doesn't work, since
|
* the complement is in range [0,2] but the other
|
* min input is [-1,1]. However, we can just clamp to 0
|
* before doing the complement...
|
*/
|
LLVMValueRef inv_dst;
|
inv_dst = lp_build_max(&bld->base, bld->base.zero, bld->dst);
|
inv_dst = lp_build_comp(&bld->base, inv_dst);
|
bld->saturate = lp_build_min(&bld->base, src_alpha, inv_dst);
|
} else {
|
if (!bld->inv_dst) {
|
bld->inv_dst = lp_build_comp(&bld->base, bld->dst);
|
}
|
bld->saturate = lp_build_min(&bld->base, src_alpha, bld->inv_dst);
|
}
|
}
|
return bld->saturate;
|
}
|
case PIPE_BLENDFACTOR_CONST_COLOR:
|
return bld->const_;
|
case PIPE_BLENDFACTOR_CONST_ALPHA:
|
return const_alpha;
|
case PIPE_BLENDFACTOR_SRC1_COLOR:
|
return bld->src1;
|
case PIPE_BLENDFACTOR_SRC1_ALPHA:
|
return src1_alpha;
|
case PIPE_BLENDFACTOR_INV_SRC_COLOR:
|
if (!bld->inv_src)
|
bld->inv_src = lp_build_comp(&bld->base, bld->src);
|
return bld->inv_src;
|
case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
|
if (!bld->inv_src_alpha)
|
bld->inv_src_alpha = lp_build_comp(&bld->base, src_alpha);
|
return bld->inv_src_alpha;
|
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:
|
if (!bld->inv_const)
|
bld->inv_const = lp_build_comp(&bld->base, bld->const_);
|
return bld->inv_const;
|
case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
|
if (!bld->inv_const_alpha)
|
bld->inv_const_alpha = lp_build_comp(&bld->base, const_alpha);
|
return bld->inv_const_alpha;
|
case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
|
return lp_build_comp(&bld->base, bld->src1);
|
case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
|
return lp_build_comp(&bld->base, src1_alpha);
|
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,
|
unsigned num_channels)
|
{
|
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, num_channels);
|
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,
|
num_channels);
|
}
|
|
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,
|
unsigned num_channels)
|
{
|
LLVMValueRef rgb_factor_, alpha_factor_;
|
enum lp_build_blend_swizzle rgb_swizzle;
|
|
if (alpha_swizzle == PIPE_SWIZZLE_X && num_channels == 1) {
|
return lp_build_blend_factor_unswizzled(bld, alpha_factor, TRUE);
|
}
|
|
rgb_factor_ = lp_build_blend_factor_unswizzled(bld, rgb_factor, FALSE);
|
|
if (alpha_swizzle != PIPE_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, num_channels);
|
} 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 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 = PIPE_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;
|
bld.has_dst_alpha = FALSE;
|
|
/* Find the alpha channel if not provided separately */
|
if (!src_alpha) {
|
for (i = 0; i < 4; ++i) {
|
if (swizzle[i] == 3) {
|
alpha_swizzle = i;
|
}
|
}
|
/*
|
* Note that we may get src_alpha included from source (and 4 channels)
|
* even if the destination doesn't have an alpha channel (for rgbx
|
* formats). Generally this shouldn't make much of a difference (we're
|
* relying on blend factors being sanitized already if there's no
|
* dst alpha).
|
*/
|
bld.has_dst_alpha = desc->swizzle[3] <= PIPE_SWIZZLE_W;
|
}
|
|
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;
|
boolean alpha_only = nr_channels == 1 && alpha_swizzle == PIPE_SWIZZLE_X;
|
|
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,
|
alpha_only ? state->alpha_src_factor : state->rgb_src_factor,
|
alpha_only ? state->alpha_dst_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 != PIPE_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;
|
}
|
