/****************************************************************************
|
* Copyright (C) 2014-2015 Intel Corporation. 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, sublicense,
|
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
|
* THE AUTHORS OR COPYRIGHT HOLDERS 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.cpp
|
*
|
* @brief Implementation for blending operations.
|
*
|
******************************************************************************/
|
#include "state.h"
|
|
template<bool Color, bool Alpha>
|
INLINE
|
void GenerateBlendFactor(SWR_BLEND_FACTOR func, simdvector &constantColor, simdvector &src, simdvector &src1, simdvector &dst, simdvector &out)
|
{
|
simdvector result;
|
|
switch (func)
|
{
|
case BLENDFACTOR_ZERO:
|
result.x = _simd_setzero_ps();
|
result.y = _simd_setzero_ps();
|
result.z = _simd_setzero_ps();
|
result.w = _simd_setzero_ps();
|
break;
|
|
case BLENDFACTOR_ONE:
|
result.x = _simd_set1_ps(1.0);
|
result.y = _simd_set1_ps(1.0);
|
result.z = _simd_set1_ps(1.0);
|
result.w = _simd_set1_ps(1.0);
|
break;
|
|
case BLENDFACTOR_SRC_COLOR:
|
result = src;
|
break;
|
|
case BLENDFACTOR_DST_COLOR:
|
result = dst;
|
break;
|
|
case BLENDFACTOR_INV_SRC_COLOR:
|
result.x = _simd_sub_ps(_simd_set1_ps(1.0), src.x);
|
result.y = _simd_sub_ps(_simd_set1_ps(1.0), src.y);
|
result.z = _simd_sub_ps(_simd_set1_ps(1.0), src.z);
|
result.w = _simd_sub_ps(_simd_set1_ps(1.0), src.w);
|
break;
|
|
case BLENDFACTOR_INV_DST_COLOR:
|
result.x = _simd_sub_ps(_simd_set1_ps(1.0), dst.x);
|
result.y = _simd_sub_ps(_simd_set1_ps(1.0), dst.y);
|
result.z = _simd_sub_ps(_simd_set1_ps(1.0), dst.z);
|
result.w = _simd_sub_ps(_simd_set1_ps(1.0), dst.w);
|
break;
|
|
case BLENDFACTOR_SRC_ALPHA: result.x = src.w;
|
result.y = src.w;
|
result.z = src.w;
|
result.w = src.w;
|
break;
|
|
case BLENDFACTOR_INV_SRC_ALPHA:
|
{
|
simdscalar oneMinusSrcA = _simd_sub_ps(_simd_set1_ps(1.0), src.w);
|
result.x = oneMinusSrcA;
|
result.y = oneMinusSrcA;
|
result.z = oneMinusSrcA;
|
result.w = oneMinusSrcA;
|
break;
|
}
|
|
case BLENDFACTOR_DST_ALPHA: result.x = dst.w;
|
result.y = dst.w;
|
result.z = dst.w;
|
result.w = dst.w;
|
break;
|
|
case BLENDFACTOR_INV_DST_ALPHA:
|
{
|
simdscalar oneMinusDstA = _simd_sub_ps(_simd_set1_ps(1.0), dst.w);
|
result.x = oneMinusDstA;
|
result.y = oneMinusDstA;
|
result.z = oneMinusDstA;
|
result.w = oneMinusDstA;
|
break;
|
}
|
|
case BLENDFACTOR_SRC_ALPHA_SATURATE:
|
{
|
simdscalar sat = _simd_min_ps(src.w, _simd_sub_ps(_simd_set1_ps(1.0), dst.w));
|
result.x = sat;
|
result.y = sat;
|
result.z = sat;
|
result.w = _simd_set1_ps(1.0);
|
break;
|
}
|
|
case BLENDFACTOR_CONST_COLOR:
|
result.x = constantColor[0];
|
result.y = constantColor[1];
|
result.z = constantColor[2];
|
result.w = constantColor[3];
|
break;
|
|
case BLENDFACTOR_CONST_ALPHA:
|
result.x = result.y = result.z = result.w = constantColor[3];
|
break;
|
|
case BLENDFACTOR_INV_CONST_COLOR:
|
{
|
result.x = _simd_sub_ps(_simd_set1_ps(1.0f), constantColor[0]);
|
result.y = _simd_sub_ps(_simd_set1_ps(1.0f), constantColor[1]);
|
result.z = _simd_sub_ps(_simd_set1_ps(1.0f), constantColor[2]);
|
result.w = _simd_sub_ps(_simd_set1_ps(1.0f), constantColor[3]);
|
break;
|
}
|
|
case BLENDFACTOR_INV_CONST_ALPHA:
|
{
|
result.x = result.y = result.z = result.w = _simd_sub_ps(_simd_set1_ps(1.0f), constantColor[3]);
|
break;
|
}
|
|
case BLENDFACTOR_SRC1_COLOR:
|
result.x = src1.x;
|
result.y = src1.y;
|
result.z = src1.z;
|
result.w = src1.w;
|
break;
|
|
case BLENDFACTOR_SRC1_ALPHA:
|
result.x = result.y = result.z = result.w = src1.w;
|
break;
|
|
case BLENDFACTOR_INV_SRC1_COLOR:
|
result.x = _simd_sub_ps(_simd_set1_ps(1.0f), src1.x);
|
result.y = _simd_sub_ps(_simd_set1_ps(1.0f), src1.y);
|
result.z = _simd_sub_ps(_simd_set1_ps(1.0f), src1.z);
|
result.w = _simd_sub_ps(_simd_set1_ps(1.0f), src1.w);
|
break;
|
|
case BLENDFACTOR_INV_SRC1_ALPHA:
|
result.x = result.y = result.z = result.w = _simd_sub_ps(_simd_set1_ps(1.0f), src1.w);
|
break;
|
|
default: SWR_INVALID("Unimplemented blend factor: %d", func);
|
}
|
|
if (Color)
|
{
|
out.x = result.x;
|
out.y = result.y;
|
out.z = result.z;
|
}
|
if (Alpha)
|
{
|
out.w = result.w;
|
}
|
|
}
|
|
template<bool Color, bool Alpha>
|
INLINE void BlendFunc(SWR_BLEND_OP blendOp, simdvector &src, simdvector &srcFactor, simdvector &dst, simdvector &dstFactor, simdvector &out)
|
{
|
simdvector result;
|
|
switch (blendOp)
|
{
|
case BLENDOP_ADD:
|
result.x = _simd_fmadd_ps(srcFactor.x, src.x, _simd_mul_ps(dstFactor.x, dst.x));
|
result.y = _simd_fmadd_ps(srcFactor.y, src.y, _simd_mul_ps(dstFactor.y, dst.y));
|
result.z = _simd_fmadd_ps(srcFactor.z, src.z, _simd_mul_ps(dstFactor.z, dst.z));
|
result.w = _simd_fmadd_ps(srcFactor.w, src.w, _simd_mul_ps(dstFactor.w, dst.w));
|
break;
|
|
case BLENDOP_SUBTRACT:
|
result.x = _simd_fmsub_ps(srcFactor.x, src.x, _simd_mul_ps(dstFactor.x, dst.x));
|
result.y = _simd_fmsub_ps(srcFactor.y, src.y, _simd_mul_ps(dstFactor.y, dst.y));
|
result.z = _simd_fmsub_ps(srcFactor.z, src.z, _simd_mul_ps(dstFactor.z, dst.z));
|
result.w = _simd_fmsub_ps(srcFactor.w, src.w, _simd_mul_ps(dstFactor.w, dst.w));
|
break;
|
|
case BLENDOP_REVSUBTRACT:
|
result.x = _simd_fmsub_ps(dstFactor.x, dst.x, _simd_mul_ps(srcFactor.x, src.x));
|
result.y = _simd_fmsub_ps(dstFactor.y, dst.y, _simd_mul_ps(srcFactor.y, src.y));
|
result.z = _simd_fmsub_ps(dstFactor.z, dst.z, _simd_mul_ps(srcFactor.z, src.z));
|
result.w = _simd_fmsub_ps(dstFactor.w, dst.w, _simd_mul_ps(srcFactor.w, src.w));
|
break;
|
|
case BLENDOP_MIN:
|
result.x = _simd_min_ps(_simd_mul_ps(srcFactor.x, src.x), _simd_mul_ps(dstFactor.x, dst.x));
|
result.y = _simd_min_ps(_simd_mul_ps(srcFactor.y, src.y), _simd_mul_ps(dstFactor.y, dst.y));
|
result.z = _simd_min_ps(_simd_mul_ps(srcFactor.z, src.z), _simd_mul_ps(dstFactor.z, dst.z));
|
result.w = _simd_min_ps(_simd_mul_ps(srcFactor.w, src.w), _simd_mul_ps(dstFactor.w, dst.w));
|
break;
|
|
case BLENDOP_MAX:
|
result.x = _simd_max_ps(_simd_mul_ps(srcFactor.x, src.x), _simd_mul_ps(dstFactor.x, dst.x));
|
result.y = _simd_max_ps(_simd_mul_ps(srcFactor.y, src.y), _simd_mul_ps(dstFactor.y, dst.y));
|
result.z = _simd_max_ps(_simd_mul_ps(srcFactor.z, src.z), _simd_mul_ps(dstFactor.z, dst.z));
|
result.w = _simd_max_ps(_simd_mul_ps(srcFactor.w, src.w), _simd_mul_ps(dstFactor.w, dst.w));
|
break;
|
|
default:
|
SWR_INVALID("Unimplemented blend function: %d", blendOp);
|
}
|
|
if (Color)
|
{
|
out.x = result.x;
|
out.y = result.y;
|
out.z = result.z;
|
}
|
if (Alpha)
|
{
|
out.w = result.w;
|
}
|
}
|
|
template<SWR_TYPE type>
|
INLINE void Clamp(simdvector &src)
|
{
|
switch (type)
|
{
|
case SWR_TYPE_FLOAT:
|
break;
|
|
case SWR_TYPE_UNORM:
|
src.x = _simd_max_ps(src.x, _simd_setzero_ps());
|
src.x = _simd_min_ps(src.x, _simd_set1_ps(1.0f));
|
|
src.y = _simd_max_ps(src.y, _simd_setzero_ps());
|
src.y = _simd_min_ps(src.y, _simd_set1_ps(1.0f));
|
|
src.z = _simd_max_ps(src.z, _simd_setzero_ps());
|
src.z = _simd_min_ps(src.z, _simd_set1_ps(1.0f));
|
|
src.w = _simd_max_ps(src.w, _simd_setzero_ps());
|
src.w = _simd_min_ps(src.w, _simd_set1_ps(1.0f));
|
break;
|
|
case SWR_TYPE_SNORM:
|
src.x = _simd_max_ps(src.x, _simd_set1_ps(-1.0f));
|
src.x = _simd_min_ps(src.x, _simd_set1_ps(1.0f));
|
|
src.y = _simd_max_ps(src.y, _simd_set1_ps(-1.0f));
|
src.y = _simd_min_ps(src.y, _simd_set1_ps(1.0f));
|
|
src.z = _simd_max_ps(src.z, _simd_set1_ps(-1.0f));
|
src.z = _simd_min_ps(src.z, _simd_set1_ps(1.0f));
|
|
src.w = _simd_max_ps(src.w, _simd_set1_ps(-1.0f));
|
src.w = _simd_min_ps(src.w, _simd_set1_ps(1.0f));
|
break;
|
|
default:
|
SWR_INVALID("Unimplemented clamp: %d", type);
|
break;
|
}
|
}
|
|
template<SWR_TYPE type>
|
void Blend(const SWR_BLEND_STATE *pBlendState, const SWR_RENDER_TARGET_BLEND_STATE *pState, simdvector &src, simdvector& src1, uint8_t *pDst, simdvector &result)
|
{
|
// load render target
|
simdvector dst;
|
LoadSOA<KNOB_COLOR_HOT_TILE_FORMAT>(pDst, dst);
|
|
simdvector constColor;
|
constColor.x = _simd_broadcast_ss(&pBlendState->constantColor[0]);
|
constColor.y = _simd_broadcast_ss(&pBlendState->constantColor[1]);
|
constColor.z = _simd_broadcast_ss(&pBlendState->constantColor[2]);
|
constColor.w = _simd_broadcast_ss(&pBlendState->constantColor[3]);
|
|
// clamp src/dst/constant
|
Clamp<type>(src);
|
Clamp<type>(src1);
|
Clamp<type>(dst);
|
Clamp<type>(constColor);
|
|
simdvector srcFactor, dstFactor;
|
if (pBlendState->independentAlphaBlendEnable)
|
{
|
GenerateBlendFactor<true, false>((SWR_BLEND_FACTOR)pState->sourceBlendFactor, constColor, src, src1, dst, srcFactor);
|
GenerateBlendFactor<false, true>((SWR_BLEND_FACTOR)pState->sourceAlphaBlendFactor, constColor, src, src1, dst, srcFactor);
|
|
GenerateBlendFactor<true, false>((SWR_BLEND_FACTOR)pState->destBlendFactor, constColor, src, src1, dst, dstFactor);
|
GenerateBlendFactor<false, true>((SWR_BLEND_FACTOR)pState->destAlphaBlendFactor, constColor, src, src1, dst, dstFactor);
|
|
BlendFunc<true, false>((SWR_BLEND_OP)pState->colorBlendFunc, src, srcFactor, dst, dstFactor, result);
|
BlendFunc<false, true>((SWR_BLEND_OP)pState->alphaBlendFunc, src, srcFactor, dst, dstFactor, result);
|
}
|
else
|
{
|
GenerateBlendFactor<true, true>((SWR_BLEND_FACTOR)pState->sourceBlendFactor, constColor, src, src1, dst, srcFactor);
|
GenerateBlendFactor<true, true>((SWR_BLEND_FACTOR)pState->destBlendFactor, constColor, src, src1, dst, dstFactor);
|
|
BlendFunc<true, true>((SWR_BLEND_OP)pState->colorBlendFunc, src, srcFactor, dst, dstFactor, result);
|
}
|
}
|
