| /*------------------------------------------------------------------------- |
| * 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 Advanced blending (GL_KHR_blend_equation_advanced) tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es31fAdvancedBlendTests.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glsFragmentOpUtil.hpp" |
| #include "glsStateQueryUtil.hpp" |
| #include "gluPixelTransfer.hpp" |
| #include "gluObjectWrapper.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluShaderProgram.hpp" |
| #include "gluCallLogWrapper.hpp" |
| #include "gluStrUtil.hpp" |
| #include "tcuPixelFormat.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuStringTemplate.hpp" |
| #include "deRandom.hpp" |
| #include "deStringUtil.hpp" |
| #include "rrFragmentOperations.hpp" |
| #include "sglrReferenceUtils.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| |
| #include <string> |
| #include <vector> |
| |
| namespace deqp |
| { |
| |
| using gls::FragmentOpUtil::IntegerQuad; |
| using gls::FragmentOpUtil::ReferenceQuadRenderer; |
| using std::map; |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| using tcu::TextureFormat; |
| using tcu::TextureLevel; |
| using tcu::UVec4; |
| using tcu::Vec2; |
| using tcu::Vec4; |
| |
| namespace gles31 |
| { |
| namespace Functional |
| { |
| |
| namespace |
| { |
| |
| enum |
| { |
| MAX_VIEWPORT_WIDTH = 128, |
| MAX_VIEWPORT_HEIGHT = 128 |
| }; |
| |
| enum RenderTargetType |
| { |
| RENDERTARGETTYPE_DEFAULT = 0, //!< Default framebuffer |
| RENDERTARGETTYPE_SRGB_FBO, |
| RENDERTARGETTYPE_MSAA_FBO, |
| |
| RENDERTARGETTYPE_LAST |
| }; |
| |
| static const char *getEquationName(glw::GLenum equation) |
| { |
| switch (equation) |
| { |
| case GL_MULTIPLY: |
| return "multiply"; |
| case GL_SCREEN: |
| return "screen"; |
| case GL_OVERLAY: |
| return "overlay"; |
| case GL_DARKEN: |
| return "darken"; |
| case GL_LIGHTEN: |
| return "lighten"; |
| case GL_COLORDODGE: |
| return "colordodge"; |
| case GL_COLORBURN: |
| return "colorburn"; |
| case GL_HARDLIGHT: |
| return "hardlight"; |
| case GL_SOFTLIGHT: |
| return "softlight"; |
| case GL_DIFFERENCE: |
| return "difference"; |
| case GL_EXCLUSION: |
| return "exclusion"; |
| case GL_HSL_HUE: |
| return "hsl_hue"; |
| case GL_HSL_SATURATION: |
| return "hsl_saturation"; |
| case GL_HSL_COLOR: |
| return "hsl_color"; |
| case GL_HSL_LUMINOSITY: |
| return "hsl_luminosity"; |
| default: |
| DE_ASSERT(false); |
| return DE_NULL; |
| } |
| } |
| |
| class AdvancedBlendCase : public TestCase |
| { |
| public: |
| AdvancedBlendCase(Context &context, const char *name, const char *desc, uint32_t mode, int overdrawCount, |
| bool coherent, RenderTargetType rtType); |
| |
| ~AdvancedBlendCase(void); |
| |
| void init(void); |
| void deinit(void); |
| |
| IterateResult iterate(void); |
| |
| private: |
| AdvancedBlendCase(const AdvancedBlendCase &); |
| AdvancedBlendCase &operator=(const AdvancedBlendCase &); |
| |
| const uint32_t m_blendMode; |
| const int m_overdrawCount; |
| const bool m_coherentBlending; |
| const RenderTargetType m_rtType; |
| const int m_numIters; |
| |
| bool m_coherentExtensionSupported; |
| |
| uint32_t m_colorRbo; |
| uint32_t m_fbo; |
| |
| uint32_t m_resolveColorRbo; |
| uint32_t m_resolveFbo; |
| |
| glu::ShaderProgram *m_program; |
| |
| ReferenceQuadRenderer *m_referenceRenderer; |
| TextureLevel *m_refColorBuffer; |
| |
| const int m_renderWidth; |
| const int m_renderHeight; |
| const int m_viewportWidth; |
| const int m_viewportHeight; |
| |
| int m_iterNdx; |
| }; |
| |
| AdvancedBlendCase::AdvancedBlendCase(Context &context, const char *name, const char *desc, uint32_t mode, |
| int overdrawCount, bool coherent, RenderTargetType rtType) |
| : TestCase(context, name, desc) |
| , m_blendMode(mode) |
| , m_overdrawCount(overdrawCount) |
| , m_coherentBlending(coherent) |
| , m_rtType(rtType) |
| , m_numIters(5) |
| , m_coherentExtensionSupported(false) |
| , m_colorRbo(0) |
| , m_fbo(0) |
| , m_resolveColorRbo(0) |
| , m_resolveFbo(0) |
| , m_program(DE_NULL) |
| , m_referenceRenderer(DE_NULL) |
| , m_refColorBuffer(DE_NULL) |
| , m_renderWidth(rtType != RENDERTARGETTYPE_DEFAULT ? 2 * MAX_VIEWPORT_WIDTH : |
| m_context.getRenderTarget().getWidth()) |
| , m_renderHeight(rtType != RENDERTARGETTYPE_DEFAULT ? 2 * MAX_VIEWPORT_HEIGHT : |
| m_context.getRenderTarget().getHeight()) |
| , m_viewportWidth(de::min<int>(m_renderWidth, MAX_VIEWPORT_WIDTH)) |
| , m_viewportHeight(de::min<int>(m_renderHeight, MAX_VIEWPORT_HEIGHT)) |
| , m_iterNdx(0) |
| { |
| } |
| |
| const char *getBlendLayoutQualifier(rr::BlendEquationAdvanced equation) |
| { |
| static const char *s_qualifiers[] = { |
| "blend_support_multiply", "blend_support_screen", "blend_support_overlay", |
| "blend_support_darken", "blend_support_lighten", "blend_support_colordodge", |
| "blend_support_colorburn", "blend_support_hardlight", "blend_support_softlight", |
| "blend_support_difference", "blend_support_exclusion", "blend_support_hsl_hue", |
| "blend_support_hsl_saturation", "blend_support_hsl_color", "blend_support_hsl_luminosity", |
| }; |
| DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_qualifiers) == rr::BLENDEQUATION_ADVANCED_LAST); |
| DE_ASSERT(de::inBounds<int>(equation, 0, rr::BLENDEQUATION_ADVANCED_LAST)); |
| return s_qualifiers[equation]; |
| } |
| |
| glu::ProgramSources getBlendProgramSrc(rr::BlendEquationAdvanced equation, glu::RenderContext &renderContext) |
| { |
| const bool supportsES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)); |
| |
| static const char *s_vertSrc = "${GLSL_VERSION_DECL}\n" |
| "in highp vec4 a_position;\n" |
| "in mediump vec4 a_color;\n" |
| "out mediump vec4 v_color;\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = a_position;\n" |
| " v_color = a_color;\n" |
| "}\n"; |
| static const char *s_fragSrc = "${GLSL_VERSION_DECL}\n" |
| "${EXTENSION}" |
| "in mediump vec4 v_color;\n" |
| "layout(${SUPPORT_QUALIFIER}) out;\n" |
| "layout(location = 0) out mediump vec4 o_color;\n" |
| "void main()\n" |
| "{\n" |
| " o_color = v_color;\n" |
| "}\n"; |
| |
| map<string, string> args; |
| args["GLSL_VERSION_DECL"] = supportsES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : |
| getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES); |
| args["EXTENSION"] = supportsES32 ? "\n" : "#extension GL_KHR_blend_equation_advanced : require\n"; |
| args["SUPPORT_QUALIFIER"] = getBlendLayoutQualifier(equation); |
| |
| return glu::ProgramSources() << glu::VertexSource(tcu::StringTemplate(s_vertSrc).specialize(args)) |
| << glu::FragmentSource(tcu::StringTemplate(s_fragSrc).specialize(args)); |
| } |
| |
| void AdvancedBlendCase::init(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| const bool useFbo = m_rtType != RENDERTARGETTYPE_DEFAULT; |
| const bool useSRGB = m_rtType == RENDERTARGETTYPE_SRGB_FBO; |
| |
| m_coherentExtensionSupported = |
| m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced_coherent"); |
| |
| if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) |
| if (!m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced")) |
| TCU_THROW(NotSupportedError, "GL_KHR_blend_equation_advanced is not supported"); |
| |
| if (m_coherentBlending && !m_coherentExtensionSupported) |
| TCU_THROW(NotSupportedError, "GL_KHR_blend_equation_advanced_coherent is not supported"); |
| |
| TCU_CHECK(gl.blendBarrier); |
| |
| DE_ASSERT(!m_program); |
| DE_ASSERT(!m_referenceRenderer); |
| DE_ASSERT(!m_refColorBuffer); |
| |
| m_program = new glu::ShaderProgram( |
| m_context.getRenderContext(), |
| getBlendProgramSrc(sglr::rr_util::mapGLBlendEquationAdvanced(m_blendMode), m_context.getRenderContext())); |
| m_testCtx.getLog() << *m_program; |
| |
| if (!m_program->isOk()) |
| { |
| delete m_program; |
| m_program = DE_NULL; |
| TCU_FAIL("Compile failed"); |
| } |
| |
| m_referenceRenderer = new ReferenceQuadRenderer; |
| m_refColorBuffer = |
| new TextureLevel(TextureFormat(useSRGB ? TextureFormat::sRGBA : TextureFormat::RGBA, TextureFormat::UNORM_INT8), |
| m_viewportWidth, m_viewportHeight); |
| |
| if (useFbo) |
| { |
| const uint32_t format = useSRGB ? GL_SRGB8_ALPHA8 : GL_RGBA8; |
| const int numSamples = m_rtType == RENDERTARGETTYPE_MSAA_FBO ? 4 : 0; |
| |
| m_testCtx.getLog() << TestLog::Message << "Using FBO of size (" << m_renderWidth << ", " << m_renderHeight |
| << ") with format " << glu::getTextureFormatStr(format) << " and " << numSamples |
| << " samples" << TestLog::EndMessage; |
| |
| gl.genRenderbuffers(1, &m_colorRbo); |
| gl.bindRenderbuffer(GL_RENDERBUFFER, m_colorRbo); |
| gl.renderbufferStorageMultisample(GL_RENDERBUFFER, numSamples, format, m_renderWidth, m_renderHeight); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create color RBO"); |
| |
| gl.genFramebuffers(1, &m_fbo); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorRbo); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create FBO"); |
| |
| TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); |
| |
| if (numSamples > 0) |
| { |
| // Create resolve FBO |
| gl.genRenderbuffers(1, &m_resolveColorRbo); |
| gl.bindRenderbuffer(GL_RENDERBUFFER, m_resolveColorRbo); |
| gl.renderbufferStorageMultisample(GL_RENDERBUFFER, 0, format, m_renderWidth, m_renderHeight); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create resolve color RBO"); |
| |
| gl.genFramebuffers(1, &m_resolveFbo); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_resolveFbo); |
| gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_resolveColorRbo); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create FBO"); |
| |
| TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| } |
| |
| if (glu::isContextTypeGLCore(m_context.getRenderContext().getType()) && useSRGB) |
| gl.enable(GL_FRAMEBUFFER_SRGB); |
| } |
| else |
| DE_ASSERT(m_rtType == RENDERTARGETTYPE_DEFAULT); |
| |
| m_iterNdx = 0; |
| } |
| |
| AdvancedBlendCase::~AdvancedBlendCase(void) |
| { |
| AdvancedBlendCase::deinit(); |
| } |
| |
| void AdvancedBlendCase::deinit(void) |
| { |
| delete m_program; |
| delete m_referenceRenderer; |
| delete m_refColorBuffer; |
| |
| m_program = DE_NULL; |
| m_referenceRenderer = DE_NULL; |
| m_refColorBuffer = DE_NULL; |
| |
| if (m_colorRbo || m_fbo) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.bindRenderbuffer(GL_RENDERBUFFER, 0); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0); |
| |
| if (m_colorRbo != 0) |
| { |
| gl.deleteRenderbuffers(1, &m_colorRbo); |
| m_colorRbo = 0; |
| } |
| |
| if (m_fbo != 0) |
| { |
| gl.deleteFramebuffers(1, &m_fbo); |
| m_fbo = 0; |
| } |
| |
| if (m_resolveColorRbo) |
| { |
| gl.deleteRenderbuffers(1, &m_resolveColorRbo); |
| m_resolveColorRbo = 0; |
| } |
| |
| if (m_resolveFbo) |
| { |
| gl.deleteRenderbuffers(1, &m_resolveFbo); |
| m_resolveFbo = 0; |
| } |
| |
| if (glu::isContextTypeGLCore(m_context.getRenderContext().getType()) && RENDERTARGETTYPE_SRGB_FBO == m_rtType) |
| gl.disable(GL_FRAMEBUFFER_SRGB); |
| } |
| } |
| |
| static tcu::Vec4 randomColor(de::Random *rnd) |
| { |
| const float rgbValues[] = {0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f}; |
| const float alphaValues[] = {0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f}; |
| |
| // \note Spec assumes premultiplied inputs. |
| const float a = rnd->choose<float>(DE_ARRAY_BEGIN(alphaValues), DE_ARRAY_END(alphaValues)); |
| const float r = a * rnd->choose<float>(DE_ARRAY_BEGIN(rgbValues), DE_ARRAY_END(rgbValues)); |
| const float g = a * rnd->choose<float>(DE_ARRAY_BEGIN(rgbValues), DE_ARRAY_END(rgbValues)); |
| const float b = a * rnd->choose<float>(DE_ARRAY_BEGIN(rgbValues), DE_ARRAY_END(rgbValues)); |
| return tcu::Vec4(r, g, b, a); |
| } |
| |
| static tcu::ConstPixelBufferAccess getLinearAccess(const tcu::ConstPixelBufferAccess &access) |
| { |
| if (access.getFormat().order == TextureFormat::sRGBA) |
| return tcu::ConstPixelBufferAccess(TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), |
| access.getWidth(), access.getHeight(), access.getDepth(), |
| access.getRowPitch(), access.getSlicePitch(), access.getDataPtr()); |
| else |
| return access; |
| } |
| |
| AdvancedBlendCase::IterateResult AdvancedBlendCase::iterate(void) |
| { |
| const glu::RenderContext &renderCtx = m_context.getRenderContext(); |
| const glw::Functions &gl = renderCtx.getFunctions(); |
| de::Random rnd(deStringHash(getName()) ^ deInt32Hash(m_iterNdx)); |
| const int viewportX = rnd.getInt(0, m_renderWidth - m_viewportWidth); |
| const int viewportY = rnd.getInt(0, m_renderHeight - m_viewportHeight); |
| const bool useFbo = m_rtType != RENDERTARGETTYPE_DEFAULT; |
| const bool requiresResolve = m_rtType == RENDERTARGETTYPE_MSAA_FBO; |
| const int numQuads = m_overdrawCount + 1; |
| TextureLevel renderedImg(TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_viewportWidth, |
| m_viewportHeight); |
| vector<Vec4> colors(numQuads * 4); |
| |
| for (vector<Vec4>::iterator col = colors.begin(); col != colors.end(); ++col) |
| *col = randomColor(&rnd); |
| |
| // Render with GL. |
| { |
| const uint32_t program = m_program->getProgram(); |
| const int posLoc = gl.getAttribLocation(program, "a_position"); |
| const int colorLoc = gl.getAttribLocation(program, "a_color"); |
| uint32_t vao = 0; |
| const glu::Buffer indexBuffer(renderCtx); |
| const glu::Buffer positionBuffer(renderCtx); |
| const glu::Buffer colorBuffer(renderCtx); |
| vector<Vec2> positions(numQuads * 4); |
| vector<uint16_t> indices(numQuads * 6); |
| const uint16_t singleQuadIndices[] = {0, 2, 1, 1, 2, 3}; |
| const Vec2 singleQuadPos[] = { |
| Vec2(-1.0f, -1.0f), |
| Vec2(-1.0f, +1.0f), |
| Vec2(+1.0f, -1.0f), |
| Vec2(+1.0f, +1.0f), |
| }; |
| |
| TCU_CHECK(posLoc >= 0 && colorLoc >= 0); |
| |
| for (int quadNdx = 0; quadNdx < numQuads; quadNdx++) |
| { |
| std::copy(DE_ARRAY_BEGIN(singleQuadPos), DE_ARRAY_END(singleQuadPos), &positions[quadNdx * 4]); |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(singleQuadIndices); ndx++) |
| indices[quadNdx * 6 + ndx] = (uint16_t)(quadNdx * 4 + singleQuadIndices[ndx]); |
| } |
| |
| if (!glu::isContextTypeES(renderCtx.getType())) |
| { |
| gl.genVertexArrays(1, &vao); |
| gl.bindVertexArray(vao); |
| } |
| |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, *indexBuffer); |
| gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (glw::GLsizeiptr)(indices.size() * sizeof(indices[0])), &indices[0], |
| GL_STATIC_DRAW); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, *positionBuffer); |
| gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)(positions.size() * sizeof(positions[0])), &positions[0], |
| GL_STATIC_DRAW); |
| gl.enableVertexAttribArray(posLoc); |
| gl.vertexAttribPointer(posLoc, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, *colorBuffer); |
| gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)(colors.size() * sizeof(colors[0])), &colors[0], |
| GL_STATIC_DRAW); |
| gl.enableVertexAttribArray(colorLoc); |
| gl.vertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create buffers"); |
| |
| gl.useProgram(program); |
| gl.viewport(viewportX, viewportY, m_viewportWidth, m_viewportHeight); |
| gl.blendEquation(m_blendMode); |
| |
| // \note coherent extension enables GL_BLEND_ADVANCED_COHERENT_KHR by default |
| if (m_coherentBlending) |
| gl.enable(GL_BLEND_ADVANCED_COHERENT_KHR); |
| else if (m_coherentExtensionSupported) |
| gl.disable(GL_BLEND_ADVANCED_COHERENT_KHR); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set render state"); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); |
| |
| gl.disable(GL_BLEND); |
| gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, DE_NULL); |
| gl.enable(GL_BLEND); |
| |
| if (!m_coherentBlending) |
| gl.blendBarrier(); |
| |
| if (m_coherentBlending) |
| { |
| gl.drawElements(GL_TRIANGLES, 6 * (numQuads - 1), GL_UNSIGNED_SHORT, |
| (const void *)(uintptr_t)(6 * sizeof(uint16_t))); |
| } |
| else |
| { |
| for (int quadNdx = 1; quadNdx < numQuads; quadNdx++) |
| { |
| gl.drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, |
| (const void *)(uintptr_t)(quadNdx * 6 * sizeof(uint16_t))); |
| gl.blendBarrier(); |
| } |
| } |
| |
| if (vao) |
| gl.deleteVertexArrays(1, &vao); |
| |
| gl.flush(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Render failed"); |
| } |
| |
| // Render reference. |
| { |
| rr::FragmentOperationState referenceState; |
| const tcu::PixelBufferAccess colorAccess = |
| gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()); |
| const tcu::PixelBufferAccess nullAccess = tcu::PixelBufferAccess(); |
| IntegerQuad quad; |
| |
| if (!useFbo && m_context.getRenderTarget().getPixelFormat().alphaBits == 0) |
| { |
| // Emulate lack of alpha by clearing to 1 and masking out alpha writes |
| tcu::clear(*m_refColorBuffer, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)); |
| referenceState.colorMask = tcu::BVec4(true, true, true, false); |
| } |
| |
| referenceState.blendEquationAdvaced = sglr::rr_util::mapGLBlendEquationAdvanced(m_blendMode); |
| |
| quad.posA = tcu::IVec2(0, 0); |
| quad.posB = tcu::IVec2(m_viewportWidth - 1, m_viewportHeight - 1); |
| |
| for (int quadNdx = 0; quadNdx < numQuads; quadNdx++) |
| { |
| referenceState.blendMode = quadNdx == 0 ? rr::BLENDMODE_NONE : rr::BLENDMODE_ADVANCED; |
| std::copy(&colors[4 * quadNdx], &colors[4 * quadNdx] + 4, &quad.color[0]); |
| m_referenceRenderer->render(colorAccess, nullAccess /* no depth */, nullAccess /* no stencil */, quad, |
| referenceState); |
| } |
| } |
| |
| if (requiresResolve) |
| { |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolveFbo); |
| gl.blitFramebuffer(0, 0, m_renderWidth, m_renderHeight, 0, 0, m_renderWidth, m_renderHeight, |
| GL_COLOR_BUFFER_BIT, GL_NEAREST); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Resolve blit failed"); |
| |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_resolveFbo); |
| } |
| |
| glu::readPixels(renderCtx, viewportX, viewportY, renderedImg.getAccess()); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()"); |
| |
| if (requiresResolve) |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| |
| { |
| const bool isHSLMode = m_blendMode == GL_HSL_HUE || m_blendMode == GL_HSL_SATURATION || |
| m_blendMode == GL_HSL_COLOR || m_blendMode == GL_HSL_LUMINOSITY; |
| bool comparePass = false; |
| |
| if (isHSLMode) |
| { |
| // Compensate for more demanding HSL code by using fuzzy comparison. |
| const float threshold = 0.002f; |
| comparePass = tcu::fuzzyCompare(m_testCtx.getLog(), "CompareResult", "Image Comparison Result", |
| getLinearAccess(m_refColorBuffer->getAccess()), renderedImg.getAccess(), |
| threshold, tcu::COMPARE_LOG_RESULT); |
| } |
| else |
| { |
| const UVec4 compareThreshold = |
| (useFbo ? tcu::PixelFormat(8, 8, 8, 8) : m_context.getRenderTarget().getPixelFormat()) |
| .getColorThreshold() |
| .toIVec() |
| .asUint() * |
| UVec4(5) / UVec4(2) + |
| UVec4(3 * m_overdrawCount); |
| |
| comparePass = tcu::bilinearCompare( |
| m_testCtx.getLog(), "CompareResult", "Image Comparison Result", |
| getLinearAccess(m_refColorBuffer->getAccess()), renderedImg.getAccess(), |
| tcu::RGBA(compareThreshold[0], compareThreshold[1], compareThreshold[2], compareThreshold[3]), |
| tcu::COMPARE_LOG_RESULT); |
| } |
| |
| if (!comparePass) |
| { |
| m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); |
| return STOP; |
| } |
| } |
| |
| m_iterNdx += 1; |
| |
| if (m_iterNdx < m_numIters) |
| return CONTINUE; |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| } |
| |
| class BlendAdvancedCoherentStateCase : public TestCase |
| { |
| public: |
| BlendAdvancedCoherentStateCase(Context &context, const char *name, const char *description, |
| gls::StateQueryUtil::QueryType type); |
| |
| private: |
| IterateResult iterate(void); |
| |
| const gls::StateQueryUtil::QueryType m_type; |
| }; |
| |
| BlendAdvancedCoherentStateCase::BlendAdvancedCoherentStateCase(Context &context, const char *name, |
| const char *description, |
| gls::StateQueryUtil::QueryType type) |
| : TestCase(context, name, description) |
| , m_type(type) |
| { |
| } |
| |
| BlendAdvancedCoherentStateCase::IterateResult BlendAdvancedCoherentStateCase::iterate(void) |
| { |
| TCU_CHECK_AND_THROW(NotSupportedError, |
| m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced_coherent"), |
| "GL_KHR_blend_equation_advanced_coherent is not supported"); |
| |
| glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: "); |
| |
| gl.enableLogging(true); |
| |
| // check inital value |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial"); |
| gls::StateQueryUtil::verifyStateBoolean(result, gl, GL_BLEND_ADVANCED_COHERENT_KHR, true, m_type); |
| } |
| |
| // check toggle |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "Toggle", "Toggle"); |
| gl.glDisable(GL_BLEND_ADVANCED_COHERENT_KHR); |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glDisable"); |
| |
| gls::StateQueryUtil::verifyStateBoolean(result, gl, GL_BLEND_ADVANCED_COHERENT_KHR, false, m_type); |
| |
| gl.glEnable(GL_BLEND_ADVANCED_COHERENT_KHR); |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glEnable"); |
| |
| gls::StateQueryUtil::verifyStateBoolean(result, gl, GL_BLEND_ADVANCED_COHERENT_KHR, true, m_type); |
| } |
| |
| result.setTestContextResult(m_testCtx); |
| return STOP; |
| } |
| |
| class BlendEquationStateCase : public TestCase |
| { |
| public: |
| BlendEquationStateCase(Context &context, const char *name, const char *description, const glw::GLenum *equations, |
| int numEquations, gls::StateQueryUtil::QueryType type); |
| |
| private: |
| IterateResult iterate(void); |
| |
| const gls::StateQueryUtil::QueryType m_type; |
| const glw::GLenum *m_equations; |
| const int m_numEquations; |
| }; |
| |
| BlendEquationStateCase::BlendEquationStateCase(Context &context, const char *name, const char *description, |
| const glw::GLenum *equations, int numEquations, |
| gls::StateQueryUtil::QueryType type) |
| : TestCase(context, name, description) |
| , m_type(type) |
| , m_equations(equations) |
| , m_numEquations(numEquations) |
| { |
| } |
| |
| BlendEquationStateCase::IterateResult BlendEquationStateCase::iterate(void) |
| { |
| if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) |
| TCU_CHECK_AND_THROW(NotSupportedError, |
| m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"), |
| "GL_KHR_blend_equation_advanced is not supported"); |
| |
| glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: "); |
| |
| gl.enableLogging(true); |
| |
| for (int ndx = 0; ndx < m_numEquations; ++ndx) |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "Type", |
| "Test " + de::toString(glu::getBlendEquationStr(m_equations[ndx]))); |
| |
| gl.glBlendEquation(m_equations[ndx]); |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBlendEquation"); |
| |
| gls::StateQueryUtil::verifyStateInteger(result, gl, GL_BLEND_EQUATION, m_equations[ndx], m_type); |
| } |
| |
| result.setTestContextResult(m_testCtx); |
| return STOP; |
| } |
| |
| class BlendEquationIndexedStateCase : public TestCase |
| { |
| public: |
| BlendEquationIndexedStateCase(Context &context, const char *name, const char *description, |
| const glw::GLenum *equations, int numEquations, gls::StateQueryUtil::QueryType type); |
| |
| private: |
| IterateResult iterate(void); |
| |
| const gls::StateQueryUtil::QueryType m_type; |
| const glw::GLenum *m_equations; |
| const int m_numEquations; |
| }; |
| |
| BlendEquationIndexedStateCase::BlendEquationIndexedStateCase(Context &context, const char *name, |
| const char *description, const glw::GLenum *equations, |
| int numEquations, gls::StateQueryUtil::QueryType type) |
| : TestCase(context, name, description) |
| , m_type(type) |
| , m_equations(equations) |
| , m_numEquations(numEquations) |
| { |
| } |
| |
| BlendEquationIndexedStateCase::IterateResult BlendEquationIndexedStateCase::iterate(void) |
| { |
| const auto &renderContext = m_context.getRenderContext(); |
| if (!glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)) && |
| !glu::contextSupports(renderContext.getType(), glu::ApiType::core(4, 5))) |
| { |
| TCU_CHECK_AND_THROW(NotSupportedError, |
| m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"), |
| "GL_KHR_blend_equation_advanced is not supported"); |
| TCU_CHECK_AND_THROW(NotSupportedError, |
| m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"), |
| "GL_EXT_draw_buffers_indexed is not supported"); |
| } |
| |
| glu::CallLogWrapper gl(renderContext.getFunctions(), m_testCtx.getLog()); |
| tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: "); |
| |
| gl.enableLogging(true); |
| |
| for (int ndx = 0; ndx < m_numEquations; ++ndx) |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "Type", |
| "Test " + de::toString(glu::getBlendEquationStr(m_equations[ndx]))); |
| |
| gl.glBlendEquationi(2, m_equations[ndx]); |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBlendEquationi"); |
| |
| gls::StateQueryUtil::verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION, 2, m_equations[ndx], m_type); |
| } |
| |
| result.setTestContextResult(m_testCtx); |
| return STOP; |
| } |
| |
| } // namespace |
| |
| AdvancedBlendTests::AdvancedBlendTests(Context &context) |
| : TestCaseGroup(context, "blend_equation_advanced", "GL_blend_equation_advanced Tests") |
| { |
| } |
| |
| AdvancedBlendTests::~AdvancedBlendTests(void) |
| { |
| } |
| |
| void AdvancedBlendTests::init(void) |
| { |
| static const glw::GLenum s_blendEquations[] = { |
| GL_MULTIPLY, GL_SCREEN, GL_OVERLAY, GL_DARKEN, GL_LIGHTEN, |
| GL_COLORDODGE, GL_COLORBURN, GL_HARDLIGHT, GL_SOFTLIGHT, GL_DIFFERENCE, |
| GL_EXCLUSION, GL_HSL_HUE, GL_HSL_SATURATION, GL_HSL_COLOR, GL_HSL_LUMINOSITY, |
| |
| }; |
| |
| tcu::TestCaseGroup *const stateQueryGroup = new tcu::TestCaseGroup(m_testCtx, "state_query", "State query tests"); |
| tcu::TestCaseGroup *const basicGroup = new tcu::TestCaseGroup(m_testCtx, "basic", "Single quad only"); |
| tcu::TestCaseGroup *const srgbGroup = new tcu::TestCaseGroup(m_testCtx, "srgb", "Advanced blending with sRGB FBO"); |
| tcu::TestCaseGroup *const msaaGroup = new tcu::TestCaseGroup(m_testCtx, "msaa", "Advanced blending with MSAA FBO"); |
| tcu::TestCaseGroup *const barrierGroup = |
| new tcu::TestCaseGroup(m_testCtx, "barrier", "Multiple overlapping quads with blend barriers"); |
| tcu::TestCaseGroup *const coherentGroup = |
| new tcu::TestCaseGroup(m_testCtx, "coherent", "Overlapping quads with coherent blending"); |
| tcu::TestCaseGroup *const coherentMsaaGroup = |
| new tcu::TestCaseGroup(m_testCtx, "coherent_msaa", "Overlapping quads with coherent blending with MSAA FBO"); |
| |
| addChild(stateQueryGroup); |
| addChild(basicGroup); |
| addChild(srgbGroup); |
| addChild(msaaGroup); |
| addChild(barrierGroup); |
| addChild(coherentGroup); |
| addChild(coherentMsaaGroup); |
| |
| // .state_query |
| { |
| using namespace gls::StateQueryUtil; |
| |
| stateQueryGroup->addChild(new BlendAdvancedCoherentStateCase( |
| m_context, "blend_advanced_coherent_getboolean", "Test BLEND_ADVANCED_COHERENT_KHR", QUERY_BOOLEAN)); |
| stateQueryGroup->addChild(new BlendAdvancedCoherentStateCase( |
| m_context, "blend_advanced_coherent_isenabled", "Test BLEND_ADVANCED_COHERENT_KHR", QUERY_ISENABLED)); |
| stateQueryGroup->addChild(new BlendAdvancedCoherentStateCase( |
| m_context, "blend_advanced_coherent_getinteger", "Test BLEND_ADVANCED_COHERENT_KHR", QUERY_INTEGER)); |
| stateQueryGroup->addChild(new BlendAdvancedCoherentStateCase( |
| m_context, "blend_advanced_coherent_getinteger64", "Test BLEND_ADVANCED_COHERENT_KHR", QUERY_INTEGER64)); |
| stateQueryGroup->addChild(new BlendAdvancedCoherentStateCase(m_context, "blend_advanced_coherent_getfloat", |
| "Test BLEND_ADVANCED_COHERENT_KHR", QUERY_FLOAT)); |
| |
| stateQueryGroup->addChild(new BlendEquationStateCase(m_context, "blend_equation_getboolean", |
| "Test BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_BOOLEAN)); |
| stateQueryGroup->addChild(new BlendEquationStateCase(m_context, "blend_equation_getinteger", |
| "Test BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_INTEGER)); |
| stateQueryGroup->addChild(new BlendEquationStateCase(m_context, "blend_equation_getinteger64", |
| "Test BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_INTEGER64)); |
| stateQueryGroup->addChild(new BlendEquationStateCase(m_context, "blend_equation_getfloat", |
| "Test BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_FLOAT)); |
| |
| stateQueryGroup->addChild(new BlendEquationIndexedStateCase( |
| m_context, "blend_equation_getbooleani_v", "Test per-attchment BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_INDEXED_BOOLEAN)); |
| stateQueryGroup->addChild(new BlendEquationIndexedStateCase( |
| m_context, "blend_equation_getintegeri_v", "Test per-attchment BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_INDEXED_INTEGER)); |
| stateQueryGroup->addChild(new BlendEquationIndexedStateCase( |
| m_context, "blend_equation_getinteger64i_v", "Test per-attchment BLEND_EQUATION", s_blendEquations, |
| DE_LENGTH_OF_ARRAY(s_blendEquations), QUERY_INDEXED_INTEGER64)); |
| } |
| |
| // others |
| for (int modeNdx = 0; modeNdx < DE_LENGTH_OF_ARRAY(s_blendEquations); modeNdx++) |
| { |
| const char *const name = getEquationName(s_blendEquations[modeNdx]); |
| const char *const desc = ""; |
| const uint32_t mode = s_blendEquations[modeNdx]; |
| |
| basicGroup->addChild(new AdvancedBlendCase(m_context, name, desc, mode, 1, false, RENDERTARGETTYPE_DEFAULT)); |
| srgbGroup->addChild(new AdvancedBlendCase(m_context, name, desc, mode, 1, false, RENDERTARGETTYPE_SRGB_FBO)); |
| msaaGroup->addChild(new AdvancedBlendCase(m_context, name, desc, mode, 1, false, RENDERTARGETTYPE_MSAA_FBO)); |
| barrierGroup->addChild(new AdvancedBlendCase(m_context, name, desc, mode, 4, false, RENDERTARGETTYPE_DEFAULT)); |
| coherentGroup->addChild(new AdvancedBlendCase(m_context, name, desc, mode, 4, true, RENDERTARGETTYPE_DEFAULT)); |
| coherentMsaaGroup->addChild( |
| new AdvancedBlendCase(m_context, name, desc, mode, 4, true, RENDERTARGETTYPE_MSAA_FBO)); |
| } |
| } |
| |
| } // namespace Functional |
| } // namespace gles31 |
| } // namespace deqp |
