/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 2.0 Module
* -------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Blend tests.
*//*--------------------------------------------------------------------*/
#include "es2fBlendTests.hpp"
#include "glsFragmentOpUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluStrUtil.hpp"
#include "tcuSurface.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuTestLog.hpp"
#include "deRandom.hpp"
#include "rrFragmentOperations.hpp"
#include "sglrReferenceUtils.hpp"
#include "glw.h"
#include <string>
#include <vector>
namespace deqp
{
using gls::FragmentOpUtil::Quad;
using gls::FragmentOpUtil::IntegerQuad;
using gls::FragmentOpUtil::QuadRenderer;
using gls::FragmentOpUtil::ReferenceQuadRenderer;
using glu::getBlendEquationName;
using glu::getBlendFactorName;
using tcu::Vec4;
using tcu::UVec4;
using tcu::TestLog;
using tcu::Surface;
using tcu::TextureFormat;
using tcu::TextureLevel;
using std::string;
using std::vector;
namespace gles2
{
namespace Functional
{
static const int MAX_VIEWPORT_WIDTH = 64;
static const int MAX_VIEWPORT_HEIGHT = 64;
struct BlendParams
{
GLenum equationRGB;
GLenum srcFuncRGB;
GLenum dstFuncRGB;
GLenum equationAlpha;
GLenum srcFuncAlpha;
GLenum dstFuncAlpha;
Vec4 blendColor;
BlendParams (GLenum equationRGB_,
GLenum srcFuncRGB_,
GLenum dstFuncRGB_,
GLenum equationAlpha_,
GLenum srcFuncAlpha_,
GLenum dstFuncAlpha_,
Vec4 blendColor_)
: equationRGB (equationRGB_)
, srcFuncRGB (srcFuncRGB_)
, dstFuncRGB (dstFuncRGB_)
, equationAlpha (equationAlpha_)
, srcFuncAlpha (srcFuncAlpha_)
, dstFuncAlpha (dstFuncAlpha_)
, blendColor (blendColor_)
{
}
};
class BlendCase : public TestCase
{
public:
BlendCase (Context& context,
const char* name,
const char* desc,
const vector<BlendParams>& paramSets);
~BlendCase (void);
void init (void);
void deinit (void);
IterateResult iterate (void);
private:
BlendCase (const BlendCase& other);
BlendCase& operator= (const BlendCase& other);
vector<BlendParams> m_paramSets;
int m_curParamSetNdx;
QuadRenderer* m_renderer;
ReferenceQuadRenderer* m_referenceRenderer;
TextureLevel* m_refColorBuffer;
Quad m_firstQuad;
Quad m_secondQuad;
IntegerQuad m_firstQuadInt;
IntegerQuad m_secondQuadInt;
int m_viewportW;
int m_viewportH;
};
BlendCase::BlendCase (Context& context,
const char* name,
const char* desc,
const vector<BlendParams>& paramSets)
: TestCase (context, name, desc)
, m_paramSets (paramSets)
, m_curParamSetNdx (0)
, m_renderer (DE_NULL)
, m_referenceRenderer (DE_NULL)
, m_refColorBuffer (DE_NULL)
, m_viewportW (0)
, m_viewportH (0)
{
DE_ASSERT(!m_paramSets.empty());
for (int i = 0; i < (int)m_paramSets.size(); i++)
DE_ASSERT(m_paramSets[i].dstFuncRGB != GL_SRC_ALPHA_SATURATE && m_paramSets[i].dstFuncAlpha != GL_SRC_ALPHA_SATURATE);
}
void BlendCase::init (void)
{
bool useRGB = m_context.getRenderTarget().getPixelFormat().alphaBits == 0;
static const Vec4 baseGradientColors[4] =
{
Vec4(0.0f, 0.5f, 1.0f, 0.5f),
Vec4(0.5f, 0.0f, 0.5f, 1.0f),
Vec4(0.5f, 1.0f, 0.5f, 0.0f),
Vec4(1.0f, 0.5f, 0.0f, 0.5f)
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(m_firstQuad.color) == DE_LENGTH_OF_ARRAY(m_firstQuadInt.color));
for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_firstQuad.color); i++)
{
m_firstQuad.color[i] = (baseGradientColors[i] - 0.5f) * 0.2f + 0.5f;
m_firstQuadInt.color[i] = m_firstQuad.color[i];
m_secondQuad.color[i] = (Vec4(1.0f) - baseGradientColors[i] - 0.5f) * 1.0f + 0.5f;
m_secondQuadInt.color[i] = m_secondQuad.color[i];
}
m_viewportW = de::min<int>(m_context.getRenderTarget().getWidth(), MAX_VIEWPORT_WIDTH);
m_viewportH = de::min<int>(m_context.getRenderTarget().getHeight(), MAX_VIEWPORT_HEIGHT);
m_firstQuadInt.posA = tcu::IVec2(0, 0);
m_secondQuadInt.posA = tcu::IVec2(0, 0);
m_firstQuadInt.posB = tcu::IVec2(m_viewportW-1, m_viewportH-1);
m_secondQuadInt.posB = tcu::IVec2(m_viewportW-1, m_viewportH-1);
DE_ASSERT(!m_renderer);
DE_ASSERT(!m_referenceRenderer);
DE_ASSERT(!m_refColorBuffer);
m_renderer = new QuadRenderer(m_context.getRenderContext(), glu::GLSL_VERSION_100_ES);
m_referenceRenderer = new ReferenceQuadRenderer;
m_refColorBuffer = new TextureLevel(TextureFormat(useRGB ? TextureFormat::RGB : TextureFormat::RGBA, TextureFormat::UNORM_INT8),
m_viewportW, m_viewportH);
m_curParamSetNdx = 0;
}
BlendCase::~BlendCase (void)
{
delete m_renderer;
delete m_referenceRenderer;
delete m_refColorBuffer;
}
void BlendCase::deinit (void)
{
delete m_renderer;
delete m_referenceRenderer;
delete m_refColorBuffer;
m_renderer = DE_NULL;
m_referenceRenderer = DE_NULL;
m_refColorBuffer = DE_NULL;
}
BlendCase::IterateResult BlendCase::iterate (void)
{
de::Random rnd (deStringHash(getName()) ^ deInt32Hash(m_curParamSetNdx));
int viewportX = rnd.getInt(0, m_context.getRenderTarget().getWidth() - m_viewportW);
int viewportY = rnd.getInt(0, m_context.getRenderTarget().getHeight() - m_viewportH);
tcu::Surface renderedImg (m_viewportW, m_viewportH);
TestLog& log (m_testCtx.getLog());
const BlendParams& paramSet = m_paramSets[m_curParamSetNdx];
rr::FragmentOperationState referenceState;
// Log the blend parameters.
log << TestLog::Message << "RGB equation = " << getBlendEquationName(paramSet.equationRGB) << TestLog::EndMessage;
log << TestLog::Message << "RGB src func = " << getBlendFactorName(paramSet.srcFuncRGB) << TestLog::EndMessage;
log << TestLog::Message << "RGB dst func = " << getBlendFactorName(paramSet.dstFuncRGB) << TestLog::EndMessage;
log << TestLog::Message << "Alpha equation = " << getBlendEquationName(paramSet.equationAlpha) << TestLog::EndMessage;
log << TestLog::Message << "Alpha src func = " << getBlendFactorName(paramSet.srcFuncAlpha) << TestLog::EndMessage;
log << TestLog::Message << "Alpha dst func = " << getBlendFactorName(paramSet.dstFuncAlpha) << TestLog::EndMessage;
log << TestLog::Message << "Blend color = (" << paramSet.blendColor.x() << ", " << paramSet.blendColor.y() << ", " << paramSet.blendColor.z() << ", " << paramSet.blendColor.w() << ")" << TestLog::EndMessage;
// Set GL state.
GLU_CHECK_CALL(glBlendEquationSeparate(paramSet.equationRGB, paramSet.equationAlpha));
GLU_CHECK_CALL(glBlendFuncSeparate(paramSet.srcFuncRGB, paramSet.dstFuncRGB, paramSet.srcFuncAlpha, paramSet.dstFuncAlpha));
GLU_CHECK_CALL(glBlendColor(paramSet.blendColor.x(), paramSet.blendColor.y(), paramSet.blendColor.z(), paramSet.blendColor.w()));
// Set reference state.
referenceState.blendRGBState.equation = sglr::rr_util::mapGLBlendEquation(paramSet.equationRGB);
referenceState.blendRGBState.srcFunc = sglr::rr_util::mapGLBlendFunc(paramSet.srcFuncRGB);
referenceState.blendRGBState.dstFunc = sglr::rr_util::mapGLBlendFunc(paramSet.dstFuncRGB);
referenceState.blendAState.equation = sglr::rr_util::mapGLBlendEquation(paramSet.equationAlpha);
referenceState.blendAState.srcFunc = sglr::rr_util::mapGLBlendFunc(paramSet.srcFuncAlpha);
referenceState.blendAState.dstFunc = sglr::rr_util::mapGLBlendFunc(paramSet.dstFuncAlpha);
referenceState.blendColor = paramSet.blendColor;
// Render with GL.
glDisable(GL_BLEND);
glViewport(viewportX, viewportY, m_viewportW, m_viewportH);
m_renderer->render(m_firstQuad);
glEnable(GL_BLEND);
m_renderer->render(m_secondQuad);
glFlush();
// Render reference.
const tcu::PixelBufferAccess nullAccess(TextureFormat(), 0, 0, 0, DE_NULL);
referenceState.blendMode = rr::BLENDMODE_NONE;
m_referenceRenderer->render(gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()), nullAccess /* no depth */, nullAccess /* no stencil */, m_firstQuadInt, referenceState);
referenceState.blendMode = rr::BLENDMODE_STANDARD;
m_referenceRenderer->render(gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()), nullAccess /* no depth */, nullAccess /* no stencil */, m_secondQuadInt, referenceState);
// Read GL image.
glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, renderedImg.getAccess());
// Compare images.
UVec4 compareThreshold = m_context.getRenderTarget().getPixelFormat().getColorThreshold().toIVec().asUint()
* UVec4(5) / UVec4(2) + UVec4(2); // \note Non-scientific ad hoc formula. Need big threshold when few color bits; blending brings extra inaccuracy.
bool comparePass = tcu::intThresholdCompare(m_testCtx.getLog(), "CompareResult", "Image Comparison Result", m_refColorBuffer->getAccess(), renderedImg.getAccess(), compareThreshold, tcu::COMPARE_LOG_RESULT);
// Fail now if images don't match.
if (!comparePass)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Image compare failed");
return STOP;
}
// Continue if param sets still remain in m_paramSets; otherwise stop.
m_curParamSetNdx++;
if (m_curParamSetNdx < (int)m_paramSets.size())
return CONTINUE;
else
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Passed");
return STOP;
}
}
BlendTests::BlendTests (Context& context)
: TestCaseGroup(context, "blend", "Blend tests")
{
}
BlendTests::~BlendTests (void)
{
}
void BlendTests::init (void)
{
struct EnumGL
{
GLenum glValue;
const char* nameStr;
};
static const EnumGL blendEquations[] =
{
{ GL_FUNC_ADD, "add" },
{ GL_FUNC_SUBTRACT, "subtract" },
{ GL_FUNC_REVERSE_SUBTRACT, "reverse_subtract" }
};
static const EnumGL blendFunctions[] =
{
{ GL_ZERO, "zero" },
{ GL_ONE, "one" },
{ GL_SRC_COLOR, "src_color" },
{ GL_ONE_MINUS_SRC_COLOR, "one_minus_src_color" },
{ GL_DST_COLOR, "dst_color" },
{ GL_ONE_MINUS_DST_COLOR, "one_minus_dst_color" },
{ GL_SRC_ALPHA, "src_alpha" },
{ GL_ONE_MINUS_SRC_ALPHA, "one_minus_src_alpha" },
{ GL_DST_ALPHA, "dst_alpha" },
{ GL_ONE_MINUS_DST_ALPHA, "one_minus_dst_alpha" },
{ GL_CONSTANT_COLOR, "constant_color" },
{ GL_ONE_MINUS_CONSTANT_COLOR, "one_minus_constant_color" },
{ GL_CONSTANT_ALPHA, "constant_alpha" },
{ GL_ONE_MINUS_CONSTANT_ALPHA, "one_minus_constant_alpha" },
{ GL_SRC_ALPHA_SATURATE, "src_alpha_saturate" }
};
const Vec4 defaultBlendColor(0.2f, 0.4f, 0.6f, 0.8f);
// Test all blend equation, src blend function, dst blend function combinations. RGB and alpha modes are the same.
{
TestCaseGroup* group = new TestCaseGroup(m_context, "equation_src_func_dst_func", "Combinations of Blend Equations and Functions");
addChild(group);
for (int equationNdx = 0; equationNdx < DE_LENGTH_OF_ARRAY(blendEquations); equationNdx++)
for (int srcFuncNdx = 0; srcFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions); srcFuncNdx++)
for (int dstFuncNdx = 0; dstFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions); dstFuncNdx++)
{
const EnumGL& eq = blendEquations[equationNdx];
const EnumGL& src = blendFunctions[srcFuncNdx];
const EnumGL& dst = blendFunctions[dstFuncNdx];
if (dst.glValue == GL_SRC_ALPHA_SATURATE) // SRC_ALPHA_SATURATE is only valid for src func.
continue;
string name = string("") + eq.nameStr + "_" + src.nameStr + "_" + dst.nameStr;
string description = string("") +
"Equations " + getBlendEquationName(eq.glValue) +
", src funcs " + getBlendFactorName(src.glValue) +
", dst funcs " + getBlendFactorName(dst.glValue);
vector<BlendParams> paramSets;
paramSets.push_back(BlendParams(eq.glValue, src.glValue, dst.glValue, eq.glValue, src.glValue, dst.glValue, defaultBlendColor));
group->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets));
}
}
// Test all RGB src, alpha src and RGB dst, alpha dst combinations. Equations are ADD.
// \note For all RGB src, alpha src combinations, also test a couple of different RGBA dst functions, and vice versa.
{
TestCaseGroup* mainGroup = new TestCaseGroup(m_context, "rgb_func_alpha_func", "Combinations of RGB and Alpha Functions");
addChild(mainGroup);
TestCaseGroup* srcGroup = new TestCaseGroup(m_context, "src", "Source functions");
TestCaseGroup* dstGroup = new TestCaseGroup(m_context, "dst", "Destination functions");
mainGroup->addChild(srcGroup);
mainGroup->addChild(dstGroup);
for (int isDstI = 0; isDstI <= 1; isDstI++)
for (int rgbFuncNdx = 0; rgbFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions); rgbFuncNdx++)
for (int alphaFuncNdx = 0; alphaFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions); alphaFuncNdx++)
{
bool isSrc = isDstI == 0;
TestCaseGroup* curGroup = isSrc ? srcGroup : dstGroup;
const EnumGL& funcRGB = blendFunctions[rgbFuncNdx];
const EnumGL& funcAlpha = blendFunctions[alphaFuncNdx];
const char* dstOrSrcStr = isSrc ? "src" : "dst";
if (!isSrc && (funcRGB.glValue == GL_SRC_ALPHA_SATURATE || funcAlpha.glValue == GL_SRC_ALPHA_SATURATE)) // SRC_ALPHA_SATURATE is only valid for src func.
continue;
string name = string("") + funcRGB.nameStr + "_" + funcAlpha.nameStr;
string description = string("") +
"RGB " + dstOrSrcStr + " func " + getBlendFactorName(funcRGB.glValue) +
", alpha " + dstOrSrcStr + " func " + getBlendFactorName(funcAlpha.glValue);
// First, make param sets as if this was a src case.
vector<BlendParams> paramSets;
paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_ONE, GL_FUNC_ADD, funcAlpha.glValue, GL_ONE, defaultBlendColor));
paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_ZERO, GL_FUNC_ADD, funcAlpha.glValue, GL_ZERO, defaultBlendColor));
paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_SRC_COLOR, GL_FUNC_ADD, funcAlpha.glValue, GL_SRC_COLOR, defaultBlendColor));
paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_DST_COLOR, GL_FUNC_ADD, funcAlpha.glValue, GL_DST_COLOR, defaultBlendColor));
// Swap src and dst params if this is a dst case.
if (!isSrc)
{
for (int i = 0; i < (int)paramSets.size(); i++)
{
std::swap(paramSets[i].srcFuncRGB, paramSets[i].dstFuncRGB);
std::swap(paramSets[i].srcFuncAlpha, paramSets[i].dstFuncAlpha);
}
}
curGroup->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets));
}
}
// Test all RGB and alpha equation combinations. Src and dst funcs are ONE for both.
{
TestCaseGroup* group = new TestCaseGroup(m_context, "rgb_equation_alpha_equation", "Combinations of RGB and Alpha Equation Combinations");
addChild(group);
for (int equationRGBNdx = 0; equationRGBNdx < DE_LENGTH_OF_ARRAY(blendEquations); equationRGBNdx++)
for (int equationAlphaNdx = 0; equationAlphaNdx < DE_LENGTH_OF_ARRAY(blendEquations); equationAlphaNdx++)
{
const EnumGL& eqRGB = blendEquations[equationRGBNdx];
const EnumGL& eqAlpha = blendEquations[equationAlphaNdx];
string name = string("") + eqRGB.nameStr + "_" + eqAlpha.nameStr;
string description = string("") +
"RGB equation " + getBlendEquationName(eqRGB.glValue) +
", alpha equation " + getBlendEquationName(eqAlpha.glValue);
vector<BlendParams> paramSets;
paramSets.push_back(BlendParams(eqRGB.glValue, GL_ONE, GL_ONE, eqAlpha.glValue, GL_ONE, GL_ONE, defaultBlendColor));
group->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets));
}
}
}
} // Functional
} // gles2
} // deqp