/*------------------------------------------------------------------------- * drawElements Quality Program OpenGL ES 3.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 "es3fBlendTests.hpp" #include "gluStrUtil.hpp" #include "glsFragmentOpUtil.hpp" #include "gluPixelTransfer.hpp" #include "tcuPixelFormat.hpp" #include "tcuTexture.hpp" #include "tcuTextureUtil.hpp" #include "tcuImageCompare.hpp" #include "tcuRenderTarget.hpp" #include "tcuTestLog.hpp" #include "deRandom.hpp" #include "rrFragmentOperations.hpp" #include "sglrReferenceUtils.hpp" #include <string> #include <vector> #include "glw.h" 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::TextureLevel; using tcu::TextureFormat; using std::string; using std::vector; namespace gles3 { namespace Functional { static const int MAX_VIEWPORT_WIDTH = 64; static const int MAX_VIEWPORT_HEIGHT = 64; static TextureLevel sRGBATextureLevelToLinear (const tcu::ConstPixelBufferAccess& sRGBAAccess) { DE_ASSERT(sRGBAAccess.getFormat().order == TextureFormat::sRGBA); int width = sRGBAAccess.getWidth(); int height = sRGBAAccess.getHeight(); TextureLevel linear (TextureFormat(TextureFormat::RGBA, sRGBAAccess.getFormat().type), width, height); tcu::PixelBufferAccess linearAccess = linear.getAccess(); for (int y = 0; y < height; y++) for (int x = 0; x < width; x++) linearAccess.setPixel(tcu::sRGBToLinear(sRGBAAccess.getPixel(x, y)), x, y); return linear; } 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, bool useSrgbFbo); ~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; bool m_useSrgbFbo; deUint32 m_colorRbo; deUint32 m_fbo; QuadRenderer* m_renderer; ReferenceQuadRenderer* m_referenceRenderer; TextureLevel* m_refColorBuffer; Quad m_firstQuad; Quad m_secondQuad; IntegerQuad m_firstQuadInt; IntegerQuad m_secondQuadInt; int m_renderWidth; int m_renderHeight; int m_viewportWidth; int m_viewportHeight; }; BlendCase::BlendCase (Context& context, const char* name, const char* desc, const vector<BlendParams>& paramSets, bool useSrgbFbo) : TestCase (context, name, desc) , m_paramSets (paramSets) , m_curParamSetNdx (0) , m_useSrgbFbo (useSrgbFbo) , m_colorRbo (0) , m_fbo (0) , m_renderer (DE_NULL) , m_referenceRenderer (DE_NULL) , m_refColorBuffer (DE_NULL) , m_renderWidth (m_useSrgbFbo ? 2*MAX_VIEWPORT_WIDTH : m_context.getRenderTarget().getWidth()) , m_renderHeight (m_useSrgbFbo ? 2*MAX_VIEWPORT_HEIGHT : m_context.getRenderTarget().getHeight()) , m_viewportWidth (0) , m_viewportHeight (0) { DE_ASSERT(!m_paramSets.empty()); } void BlendCase::init (void) { bool useRGB = !m_useSrgbFbo && 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_viewportWidth = de::min<int>(m_renderWidth, MAX_VIEWPORT_WIDTH); m_viewportHeight = de::min<int>(m_renderHeight, MAX_VIEWPORT_HEIGHT); m_firstQuadInt.posA = tcu::IVec2(0, 0); m_secondQuadInt.posA = tcu::IVec2(0, 0); m_firstQuadInt.posB = tcu::IVec2(m_viewportWidth-1, m_viewportHeight-1); m_secondQuadInt.posB = tcu::IVec2(m_viewportWidth-1, m_viewportHeight-1); DE_ASSERT(!m_renderer); DE_ASSERT(!m_referenceRenderer); DE_ASSERT(!m_refColorBuffer); m_renderer = new QuadRenderer(m_context.getRenderContext(), glu::GLSL_VERSION_300_ES); m_referenceRenderer = new ReferenceQuadRenderer; m_refColorBuffer = new TextureLevel(TextureFormat(m_useSrgbFbo ? TextureFormat::sRGBA : useRGB ? TextureFormat::RGB : TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_viewportWidth, m_viewportHeight); m_curParamSetNdx = 0; if (m_useSrgbFbo) { m_testCtx.getLog() << TestLog::Message << "Using FBO of size (" << m_renderWidth << ", " << m_renderHeight << ") with format GL_SRGB8_ALPHA8" << TestLog::EndMessage; GLU_CHECK_CALL(glGenRenderbuffers(1, &m_colorRbo)); GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, m_colorRbo)); GLU_CHECK_CALL(glRenderbufferStorage(GL_RENDERBUFFER, GL_SRGB8_ALPHA8, m_renderWidth, m_renderHeight)); GLU_CHECK_CALL(glGenFramebuffers(1, &m_fbo)); GLU_CHECK_CALL(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo)); GLU_CHECK_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorRbo)); } } BlendCase::~BlendCase (void) { BlendCase::deinit(); } 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; GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0)); GLU_CHECK_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0)); if (m_colorRbo != 0) { GLU_CHECK_CALL(glDeleteRenderbuffers(1, &m_colorRbo)); m_colorRbo = 0; } if (m_fbo != 0) { GLU_CHECK_CALL(glDeleteFramebuffers(1, &m_fbo)); m_fbo = 0; } } BlendCase::IterateResult BlendCase::iterate (void) { de::Random rnd (deStringHash(getName()) ^ deInt32Hash(m_curParamSetNdx)); int viewportX = rnd.getInt(0, m_renderWidth - m_viewportWidth); int viewportY = rnd.getInt(0, m_renderHeight - m_viewportHeight); TextureLevel renderedImg (TextureFormat(m_useSrgbFbo ? TextureFormat::sRGBA : TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_viewportWidth, m_viewportHeight); 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_viewportWidth, m_viewportHeight); 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. // \note In sRGB cases, convert to linear space for comparison. UVec4 compareThreshold = (m_useSrgbFbo ? tcu::PixelFormat(8, 8, 8, 8) : m_context.getRenderTarget().getPixelFormat()).getColorThreshold().toIVec().asUint() * UVec4(5) / UVec4(2) + UVec4(m_useSrgbFbo ? 5 : 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_useSrgbFbo ? sRGBATextureLevelToLinear(*m_refColorBuffer) : *m_refColorBuffer).getAccess(), (m_useSrgbFbo ? sRGBATextureLevelToLinear(renderedImg) : 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" }, { GL_MIN, "min" }, { GL_MAX, "max" } }; 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); for (int useSrgbFboI = 0; useSrgbFboI <= 1; useSrgbFboI++) { bool useSrgbFbo = useSrgbFboI != 0; TestCaseGroup* fbGroup = new TestCaseGroup(m_context, useSrgbFbo ? "fbo_srgb" : "default_framebuffer", useSrgbFbo ? "Use a FBO with GL_SRGB8_ALPHA8" : "Use the default framebuffer"); addChild(fbGroup); // 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"); fbGroup->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 ((eq.glValue == GL_MIN || eq.glValue == GL_MAX) && (srcFuncNdx > 0 || dstFuncNdx > 0)) // MIN and MAX don't depend on factors. continue; string name = eq.nameStr; string description = string("") + "Equations " + getBlendEquationName(eq.glValue) + ", src funcs " + getBlendFactorName(src.glValue) + ", dst funcs " + getBlendFactorName(dst.glValue); if (eq.glValue != GL_MIN && eq.glValue != GL_MAX) name += string("") + "_" + src.nameStr + "_" + dst.nameStr; 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, useSrgbFbo)); } } // 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"); fbGroup->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"; 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, useSrgbFbo)); } } // 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"); fbGroup->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, useSrgbFbo)); } } } } } // Functional } // gles3 } // deqp