/*------------------------------------------------------------------------- * 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 Invariance tests. *//*--------------------------------------------------------------------*/ #include "es2fShaderInvarianceTests.hpp" #include "deStringUtil.hpp" #include "deRandom.hpp" #include "gluContextInfo.hpp" #include "gluRenderContext.hpp" #include "gluShaderProgram.hpp" #include "gluPixelTransfer.hpp" #include "glwFunctions.hpp" #include "glwEnums.hpp" #include "tcuRenderTarget.hpp" #include "tcuTestLog.hpp" #include "tcuSurface.hpp" #include "tcuTextureUtil.hpp" #include "tcuStringTemplate.hpp" namespace deqp { namespace gles2 { namespace Functional { namespace { class FormatArgumentList; static tcu::Vec4 genRandomVector(de::Random &rnd) { tcu::Vec4 retVal; retVal.x() = rnd.getFloat(-1.0f, 1.0f); retVal.y() = rnd.getFloat(-1.0f, 1.0f); retVal.z() = rnd.getFloat(-1.0f, 1.0f); retVal.w() = rnd.getFloat(0.2f, 1.0f); return retVal; } class FormatArgument { public: FormatArgument(const char *name, const std::string &value); private: friend class FormatArgumentList; const char *const m_name; const std::string m_value; }; FormatArgument::FormatArgument(const char *name, const std::string &value) : m_name(name), m_value(value) { } class FormatArgumentList { public: FormatArgumentList(void); FormatArgumentList &operator<<(const FormatArgument &); const std::map &getArguments(void) const; private: std::map m_formatArguments; }; FormatArgumentList::FormatArgumentList(void) { } FormatArgumentList &FormatArgumentList::operator<<(const FormatArgument &arg) { m_formatArguments[arg.m_name] = arg.m_value; return *this; } const std::map &FormatArgumentList::getArguments(void) const { return m_formatArguments; } static std::string formatGLSL(const char *templateString, const FormatArgumentList &args) { const std::map ¶ms = args.getArguments(); return tcu::StringTemplate(std::string(templateString)).specialize(params); } /*--------------------------------------------------------------------*//*! * \brief Vertex shader invariance test * * Test vertex shader invariance by drawing a test pattern two times, each * time with a different shader. Shaders have set identical values to * invariant gl_Position using identical expressions. No fragments from the * first pass using should remain visible. *//*--------------------------------------------------------------------*/ class InvarianceTest : public TestCase { public: struct ShaderPair { std::string vertexShaderSource0; std::string fragmentShaderSource0; std::string vertexShaderSource1; std::string fragmentShaderSource1; }; InvarianceTest(Context &ctx, const char *name, const char *desc); ~InvarianceTest(void); void init(void); void deinit(void); IterateResult iterate(void); private: virtual ShaderPair genShaders(void) const = DE_NULL; bool checkImage(const tcu::Surface &) const; glu::ShaderProgram *m_shader0; glu::ShaderProgram *m_shader1; glw::GLuint m_arrayBuf; int m_verticesInPattern; const int m_renderSize; }; InvarianceTest::InvarianceTest(Context &ctx, const char *name, const char *desc) : TestCase(ctx, name, desc) , m_shader0(DE_NULL) , m_shader1(DE_NULL) , m_arrayBuf(0) , m_verticesInPattern(0) , m_renderSize(256) { } InvarianceTest::~InvarianceTest(void) { deinit(); } void InvarianceTest::init(void) { // Invariance tests require drawing to the screen and reading back results. // Tests results are not reliable if the resolution is too small { if (m_context.getRenderTarget().getWidth() < m_renderSize || m_context.getRenderTarget().getHeight() < m_renderSize) throw tcu::NotSupportedError(std::string("Render target size must be at least ") + de::toString(m_renderSize) + "x" + de::toString(m_renderSize)); } // Gen shaders { ShaderPair vertexShaders = genShaders(); m_shader0 = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(vertexShaders.vertexShaderSource0) << glu::FragmentSource(vertexShaders.fragmentShaderSource0)); if (!m_shader0->isOk()) { m_testCtx.getLog() << *m_shader0; throw tcu::TestError("Test shader compile failed."); } m_shader1 = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(vertexShaders.vertexShaderSource1) << glu::FragmentSource(vertexShaders.fragmentShaderSource1)); if (!m_shader1->isOk()) { m_testCtx.getLog() << *m_shader1; throw tcu::TestError("Test shader compile failed."); } // log m_testCtx.getLog() << tcu::TestLog::Message << "Shader 1:" << tcu::TestLog::EndMessage << *m_shader0 << tcu::TestLog::Message << "Shader 2:" << tcu::TestLog::EndMessage << *m_shader1; } // Gen test pattern { const int numTriangles = 72; de::Random rnd(123); std::vector triangles(numTriangles * 3 * 2); const glw::Functions &gl = m_context.getRenderContext().getFunctions(); // Narrow triangle pattern for (int triNdx = 0; triNdx < numTriangles; ++triNdx) { const tcu::Vec4 vertex1 = genRandomVector(rnd); const tcu::Vec4 vertex2 = genRandomVector(rnd); const tcu::Vec4 vertex3 = vertex2 + genRandomVector(rnd) * 0.01f; // generate narrow triangles triangles[triNdx * 3 + 0] = vertex1; triangles[triNdx * 3 + 1] = vertex2; triangles[triNdx * 3 + 2] = vertex3; } // Normal triangle pattern for (int triNdx = 0; triNdx < numTriangles; ++triNdx) { triangles[(numTriangles + triNdx) * 3 + 0] = genRandomVector(rnd); triangles[(numTriangles + triNdx) * 3 + 1] = genRandomVector(rnd); triangles[(numTriangles + triNdx) * 3 + 2] = genRandomVector(rnd); } // upload gl.genBuffers(1, &m_arrayBuf); gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuf); gl.bufferData(GL_ARRAY_BUFFER, (int)(triangles.size() * sizeof(tcu::Vec4)), &triangles[0], GL_STATIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "buffer gen"); m_verticesInPattern = numTriangles * 3; } } void InvarianceTest::deinit(void) { delete m_shader0; delete m_shader1; m_shader0 = DE_NULL; m_shader1 = DE_NULL; if (m_arrayBuf) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_arrayBuf); m_arrayBuf = 0; } } InvarianceTest::IterateResult InvarianceTest::iterate(void) { const glw::Functions &gl = m_context.getRenderContext().getFunctions(); const bool depthBufferExists = m_context.getRenderTarget().getDepthBits() != 0; tcu::Surface resultSurface(m_renderSize, m_renderSize); bool error = false; // Prepare draw gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f); gl.clear(GL_COLOR_BUFFER_BIT); gl.viewport(0, 0, m_renderSize, m_renderSize); gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuf); GLU_EXPECT_NO_ERROR(gl.getError(), "setup draw"); m_testCtx.getLog() << tcu::TestLog::Message << "Testing position invariance." << tcu::TestLog::EndMessage; // Draw position check passes for (int passNdx = 0; passNdx < 2; ++passNdx) { const glu::ShaderProgram &shader = (passNdx == 0) ? (*m_shader0) : (*m_shader1); const glw::GLint positionLoc = gl.getAttribLocation(shader.getProgram(), "a_input"); const glw::GLint colorLoc = gl.getUniformLocation(shader.getProgram(), "u_color"); const tcu::Vec4 red = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f); const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); const tcu::Vec4 color = (passNdx == 0) ? (red) : (green); const char *const colorStr = (passNdx == 0) ? ("red - purple") : ("green"); m_testCtx.getLog() << tcu::TestLog::Message << "Drawing position test pattern using shader " << (passNdx + 1) << ". Primitive color: " << colorStr << "." << tcu::TestLog::EndMessage; gl.useProgram(shader.getProgram()); gl.uniform4fv(colorLoc, 1, color.getPtr()); gl.enableVertexAttribArray(positionLoc); gl.vertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), DE_NULL); gl.drawArrays(GL_TRIANGLES, 0, m_verticesInPattern); gl.disableVertexAttribArray(positionLoc); GLU_EXPECT_NO_ERROR(gl.getError(), "draw pass"); } // Read result glu::readPixels(m_context.getRenderContext(), 0, 0, resultSurface.getAccess()); // Check there are no red pixels m_testCtx.getLog() << tcu::TestLog::Message << "Verifying output. Expecting only green or background colored pixels." << tcu::TestLog::EndMessage; error |= !checkImage(resultSurface); if (!depthBufferExists) { m_testCtx.getLog() << tcu::TestLog::Message << "Depth buffer not available, skipping z-test." << tcu::TestLog::EndMessage; } else { // Test with Z-test gl.clearDepthf(1.0f); gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); gl.enable(GL_DEPTH_TEST); m_testCtx.getLog() << tcu::TestLog::Message << "Testing position invariance with z-test. Enabling GL_DEPTH_TEST." << tcu::TestLog::EndMessage; // Draw position check passes for (int passNdx = 0; passNdx < 2; ++passNdx) { const glu::ShaderProgram &shader = (passNdx == 0) ? (*m_shader0) : (*m_shader1); const glw::GLint positionLoc = gl.getAttribLocation(shader.getProgram(), "a_input"); const glw::GLint colorLoc = gl.getUniformLocation(shader.getProgram(), "u_color"); const tcu::Vec4 red = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f); const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); const tcu::Vec4 color = (passNdx == 0) ? (red) : (green); const glw::GLenum depthFunc = (passNdx == 0) ? (GL_ALWAYS) : (GL_EQUAL); const char *const depthFuncStr = (passNdx == 0) ? ("GL_ALWAYS") : ("GL_EQUAL"); const char *const colorStr = (passNdx == 0) ? ("red - purple") : ("green"); m_testCtx.getLog() << tcu::TestLog::Message << "Drawing Z-test pattern using shader " << (passNdx + 1) << ". Primitive color: " << colorStr << ". DepthFunc: " << depthFuncStr << tcu::TestLog::EndMessage; gl.useProgram(shader.getProgram()); gl.uniform4fv(colorLoc, 1, color.getPtr()); gl.depthFunc(depthFunc); gl.enableVertexAttribArray(positionLoc); gl.vertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), DE_NULL); gl.drawArrays(GL_TRIANGLES, m_verticesInPattern, m_verticesInPattern); // !< buffer contains 2 m_verticesInPattern-sized patterns gl.disableVertexAttribArray(positionLoc); GLU_EXPECT_NO_ERROR(gl.getError(), "draw pass"); } // Read result glu::readPixels(m_context.getRenderContext(), 0, 0, resultSurface.getAccess()); // Check there are no red pixels m_testCtx.getLog() << tcu::TestLog::Message << "Verifying output. Expecting only green or background colored pixels." << tcu::TestLog::EndMessage; error |= !checkImage(resultSurface); } // Report result if (error) m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Detected variance between two invariant values"); else m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); return STOP; } bool InvarianceTest::checkImage(const tcu::Surface &surface) const { const tcu::IVec4 okColor = tcu::IVec4(0, 255, 0, 255); const tcu::RGBA errColor = tcu::RGBA(255, 0, 0, 255); bool error = false; tcu::Surface errorMask(m_renderSize, m_renderSize); tcu::clear(errorMask.getAccess(), okColor); for (int y = 0; y < m_renderSize; ++y) for (int x = 0; x < m_renderSize; ++x) { const tcu::RGBA col = surface.getPixel(x, y); if (col.getRed() != 0) { errorMask.setPixel(x, y, errColor); error = true; } } // report error if (error) { m_testCtx.getLog() << tcu::TestLog::Message << "Invalid pixels found (fragments from first render pass found). Variance detected." << tcu::TestLog::EndMessage; m_testCtx.getLog() << tcu::TestLog::ImageSet("Results", "Result verification") << tcu::TestLog::Image("Result", "Result", surface) << tcu::TestLog::Image("Error mask", "Error mask", errorMask) << tcu::TestLog::EndImageSet; return false; } else { m_testCtx.getLog() << tcu::TestLog::Message << "No variance found." << tcu::TestLog::EndMessage; m_testCtx.getLog() << tcu::TestLog::ImageSet("Results", "Result verification") << tcu::TestLog::Image("Result", "Result", surface) << tcu::TestLog::EndImageSet; return true; } } class BasicInvarianceTest : public InvarianceTest { public: BasicInvarianceTest(Context &ctx, const char *name, const char *desc, const std::string &vertexShader1, const std::string &vertexShader2); ShaderPair genShaders(void) const; private: const std::string m_vertexShader1; const std::string m_vertexShader2; const std::string m_fragmentShader; static const char *const s_basicFragmentShader; }; const char *const BasicInvarianceTest::s_basicFragmentShader = "uniform mediump vec4 u_color;\n" "varying mediump vec4 v_unrelated;\n" "void main ()\n" "{\n" " mediump float blue = dot(v_unrelated, vec4(1.0, 1.0, 1.0, 1.0));\n" " gl_FragColor = vec4(u_color.r, u_color.g, blue, u_color.a);\n" "}\n"; BasicInvarianceTest::BasicInvarianceTest(Context &ctx, const char *name, const char *desc, const std::string &vertexShader1, const std::string &vertexShader2) : InvarianceTest(ctx, name, desc) , m_vertexShader1(vertexShader1) , m_vertexShader2(vertexShader2) , m_fragmentShader(s_basicFragmentShader) { } BasicInvarianceTest::ShaderPair BasicInvarianceTest::genShaders(void) const { ShaderPair retVal; retVal.vertexShaderSource0 = m_vertexShader1; retVal.vertexShaderSource1 = m_vertexShader2; retVal.fragmentShaderSource0 = m_fragmentShader; retVal.fragmentShaderSource1 = m_fragmentShader; return retVal; } } // namespace ShaderInvarianceTests::ShaderInvarianceTests(Context &context) : TestCaseGroup(context, "invariance", "Invariance tests") { } ShaderInvarianceTests::~ShaderInvarianceTests(void) { } void ShaderInvarianceTests::init(void) { static const struct PrecisionCase { glu::Precision prec; const char *name; // set literals in the glsl to be in the representable range const char *highValue; // !< highValue < maxValue const char *invHighValue; const char *mediumValue; // !< mediumValue^2 < maxValue const char *lowValue; // !< lowValue^4 < maxValue const char *invlowValue; int loopIterations; int loopPartialIterations; int loopNormalizationExponent; const char *loopNormalizationConstantLiteral; const char *loopMultiplier; const char *sumLoopNormalizationConstantLiteral; } precisions[] = { {glu::PRECISION_HIGHP, "highp", "1.0e20", "1.0e-20", "1.0e14", "1.0e9", "1.0e-9", 14, 11, 2, "1.0e4", "1.9", "1.0e3"}, {glu::PRECISION_MEDIUMP, "mediump", "1.0e4", "1.0e-4", "1.0e2", "1.0e1", "1.0e-1", 13, 11, 2, "1.0e4", "1.9", "1.0e3"}, {glu::PRECISION_LOWP, "lowp", "0.9", "1.1", "1.1", "1.15", "0.87", 6, 2, 0, "2.0", "1.1", "1.0"}, }; for (int precNdx = 0; precNdx < DE_LENGTH_OF_ARRAY(precisions); ++precNdx) { const char *const precisionName = precisions[precNdx].name; const glu::Precision precision = precisions[precNdx].prec; tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, precisionName, "Invariance tests using the given precision."); const FormatArgumentList args = FormatArgumentList() << FormatArgument("VERSION", "") << FormatArgument("IN", "attribute") << FormatArgument("OUT", "varying") << FormatArgument("IN_PREC", precisionName) << FormatArgument("HIGH_VALUE", de::toString(precisions[precNdx].highValue)) << FormatArgument("HIGH_VALUE_INV", de::toString(precisions[precNdx].invHighValue)) << FormatArgument("MEDIUM_VALUE", de::toString(precisions[precNdx].mediumValue)) << FormatArgument("LOW_VALUE", de::toString(precisions[precNdx].lowValue)) << FormatArgument("LOW_VALUE_INV", de::toString(precisions[precNdx].invlowValue)) << FormatArgument("LOOP_ITERS", de::toString(precisions[precNdx].loopIterations)) << FormatArgument("LOOP_ITERS_PARTIAL", de::toString(precisions[precNdx].loopPartialIterations)) << FormatArgument("LOOP_NORM_FRACT_EXP", de::toString(precisions[precNdx].loopNormalizationExponent)) << FormatArgument("LOOP_NORM_LITERAL", precisions[precNdx].loopNormalizationConstantLiteral) << FormatArgument("LOOP_MULTIPLIER", precisions[precNdx].loopMultiplier) << FormatArgument("SUM_LOOP_NORM_LITERAL", precisions[precNdx].sumLoopNormalizationConstantLiteral); addChild(group); // subexpression cases { // First shader shares "${HIGH_VALUE}*a_input.x*a_input.xxxx + ${HIGH_VALUE}*a_input.y*a_input.yyyy" with unrelated output variable. Reordering might result in accuracy loss // due to the high exponent. In the second shader, the high exponent may be removed during compilation. group->addChild(new BasicInvarianceTest( m_context, "common_subexpression_0", "Shader shares a subexpression with an unrelated variable.", formatGLSL( "${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " v_unrelated = a_input.xzxz + (${HIGH_VALUE}*a_input.x*a_input.xxxx + " "${HIGH_VALUE}*a_input.y*a_input.yyyy) * (1.08 * a_input.zyzy * a_input.xzxz) * ${HIGH_VALUE_INV} " "* (a_input.z * a_input.zzxz - a_input.z * a_input.zzxz) + (${HIGH_VALUE}*a_input.x*a_input.xxxx + " "${HIGH_VALUE}*a_input.y*a_input.yyyy) / ${HIGH_VALUE};\n" " gl_Position = a_input + (${HIGH_VALUE}*a_input.x*a_input.xxxx + " "${HIGH_VALUE}*a_input.y*a_input.yyyy) * ${HIGH_VALUE_INV};\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " gl_Position = a_input + (${HIGH_VALUE}*a_input.x*a_input.xxxx + " "${HIGH_VALUE}*a_input.y*a_input.yyyy) * ${HIGH_VALUE_INV};\n" "}\n", args))); // In the first shader, the unrelated variable "d" has mathematically the same expression as "e", but the different // order of calculation might cause different results. group->addChild(new BasicInvarianceTest( m_context, "common_subexpression_1", "Shader shares a subexpression with an unrelated variable.", formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 a = ${HIGH_VALUE} * a_input.zzxx + a_input.xzxy - ${HIGH_VALUE} * " "a_input.zzxx;\n" " ${IN_PREC} vec4 b = ${HIGH_VALUE} * a_input.zzxx;\n" " ${IN_PREC} vec4 c = b - ${HIGH_VALUE} * a_input.zzxx + a_input.xzxy;\n" " ${IN_PREC} vec4 d = (${LOW_VALUE} * a_input.yzxx) * (${LOW_VALUE} * a_input.yzzw) * " "(1.1*${LOW_VALUE_INV} * a_input.yzxx) * (${LOW_VALUE_INV} * a_input.xzzy);\n" " ${IN_PREC} vec4 e = ((${LOW_VALUE} * a_input.yzxx) * (1.1*${LOW_VALUE_INV} * " "a_input.yzxx)) * ((${LOW_VALUE_INV} * a_input.xzzy) * (${LOW_VALUE} * a_input.yzzw));\n" " v_unrelated = a + b + c + d + e;\n" " gl_Position = a_input + fract(c) + e;\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 b = ${HIGH_VALUE} * a_input.zzxx;\n" " ${IN_PREC} vec4 c = b - ${HIGH_VALUE} * a_input.zzxx + a_input.xzxy;\n" " ${IN_PREC} vec4 e = ((${LOW_VALUE} * a_input.yzxx) * (1.1*${LOW_VALUE_INV} * " "a_input.yzxx)) * ((${LOW_VALUE_INV} * a_input.xzzy) * (${LOW_VALUE} * a_input.yzzw));\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " gl_Position = a_input + fract(c) + e;\n" "}\n", args))); // Intermediate values used by an unrelated output variable group->addChild(new BasicInvarianceTest( m_context, "common_subexpression_2", "Shader shares a subexpression with an unrelated variable.", formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 a = ${MEDIUM_VALUE} * (a_input.xxxx + a_input.yyyy);\n" " ${IN_PREC} vec4 b = (${MEDIUM_VALUE} * (a_input.xxxx + a_input.yyyy)) * " "(${MEDIUM_VALUE} * (a_input.xxxx + a_input.yyyy)) / ${MEDIUM_VALUE} / ${MEDIUM_VALUE};\n" " ${IN_PREC} vec4 c = a * a;\n" " ${IN_PREC} vec4 d = c / ${MEDIUM_VALUE} / ${MEDIUM_VALUE};\n" " v_unrelated = a + b + c + d;\n" " gl_Position = a_input + d;\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 a = ${MEDIUM_VALUE} * (a_input.xxxx + a_input.yyyy);\n" " ${IN_PREC} vec4 c = a * a;\n" " ${IN_PREC} vec4 d = c / ${MEDIUM_VALUE} / ${MEDIUM_VALUE};\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " gl_Position = a_input + d;\n" "}\n", args))); // Invariant value can be calculated using unrelated value group->addChild(new BasicInvarianceTest(m_context, "common_subexpression_3", "Shader shares a subexpression with an unrelated variable.", formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} float x = a_input.x * 0.2;\n" " ${IN_PREC} vec4 a = a_input.xxyx * 0.7;\n" " ${IN_PREC} vec4 b = a_input.yxyz * 0.7;\n" " ${IN_PREC} vec4 c = a_input.zxyx * 0.5;\n" " ${IN_PREC} vec4 f = x*a + x*b + x*c;\n" " v_unrelated = f;\n" " ${IN_PREC} vec4 g = x * (a + b + c);\n" " gl_Position = a_input + g;\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} float x = a_input.x * 0.2;\n" " ${IN_PREC} vec4 a = a_input.xxyx * 0.7;\n" " ${IN_PREC} vec4 b = a_input.yxyz * 0.7;\n" " ${IN_PREC} vec4 c = a_input.zxyx * 0.5;\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " ${IN_PREC} vec4 g = x * (a + b + c);\n" " gl_Position = a_input + g;\n" "}\n", args))); } // shared subexpression of different precision { for (int precisionOther = glu::PRECISION_LOWP; precisionOther != glu::PRECISION_LAST; ++precisionOther) { const char *const unrelatedPrec = glu::getPrecisionName((glu::Precision)precisionOther); const glu::Precision minPrecision = (precisionOther < (int)precision) ? ((glu::Precision)precisionOther) : (precision); const char *const multiplierStr = (minPrecision == glu::PRECISION_LOWP) ? ("0.8, 0.4, -0.2, 0.3") : ("1.0e1, 5.0e2, 2.0e2, 1.0"); const char *const normalizationStrUsed = (minPrecision == glu::PRECISION_LOWP) ? ("vec4(fract(used2).xyz, 0.0)") : ("vec4(fract(used2 / 1.0e2).xyz - fract(used2 / 1.0e3).xyz, 0.0)"); const char *const normalizationStrUnrelated = (minPrecision == glu::PRECISION_LOWP) ? ("vec4(fract(unrelated2).xyz, 0.0)") : ("vec4(fract(unrelated2 / 1.0e2).xyz - fract(unrelated2 / 1.0e3).xyz, 0.0)"); group->addChild(new BasicInvarianceTest( m_context, ("subexpression_precision_" + std::string(unrelatedPrec)).c_str(), "Shader shares subexpression of different precision with an unrelated variable.", formatGLSL( "${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} ${UNRELATED_PREC} vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${UNRELATED_PREC} vec4 unrelated0 = a_input + vec4(0.1, 0.2, 0.3, 0.4);\n" " ${UNRELATED_PREC} vec4 unrelated1 = vec4(${MULTIPLIER}) * unrelated0.xywz + unrelated0;\n" " ${UNRELATED_PREC} vec4 unrelated2 = refract(unrelated1, unrelated0, distance(unrelated0, " "unrelated1));\n" " v_unrelated = a_input + 0.02 * ${NORMALIZE_UNRELATED};\n" " ${IN_PREC} vec4 used0 = a_input + vec4(0.1, 0.2, 0.3, 0.4);\n" " ${IN_PREC} vec4 used1 = vec4(${MULTIPLIER}) * used0.xywz + used0;\n" " ${IN_PREC} vec4 used2 = refract(used1, used0, distance(used0, used1));\n" " gl_Position = a_input + 0.02 * ${NORMALIZE_USED};\n" "}\n", FormatArgumentList(args) << FormatArgument("UNRELATED_PREC", unrelatedPrec) << FormatArgument("MULTIPLIER", multiplierStr) << FormatArgument("NORMALIZE_USED", normalizationStrUsed) << FormatArgument("NORMALIZE_UNRELATED", normalizationStrUnrelated)), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} ${UNRELATED_PREC} vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " ${IN_PREC} vec4 used0 = a_input + vec4(0.1, 0.2, 0.3, 0.4);\n" " ${IN_PREC} vec4 used1 = vec4(${MULTIPLIER}) * used0.xywz + used0;\n" " ${IN_PREC} vec4 used2 = refract(used1, used0, distance(used0, used1));\n" " gl_Position = a_input + 0.02 * ${NORMALIZE_USED};\n" "}\n", FormatArgumentList(args) << FormatArgument("UNRELATED_PREC", unrelatedPrec) << FormatArgument("MULTIPLIER", multiplierStr) << FormatArgument("NORMALIZE_USED", normalizationStrUsed) << FormatArgument("NORMALIZE_UNRELATED", normalizationStrUnrelated)))); } } // loops { group->addChild(new BasicInvarianceTest( m_context, "loop_0", "Invariant value set using a loop", formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} highp vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " v_unrelated += value;\n" " }\n" " gl_Position = vec4(value.xyz / ${LOOP_NORM_LITERAL} + a_input.xyz * 0.1, 1.0);\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} highp vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " }\n" " gl_Position = vec4(value.xyz / ${LOOP_NORM_LITERAL} + a_input.xyz * 0.1, 1.0);\n" "}\n", args))); group->addChild(new BasicInvarianceTest( m_context, "loop_1", "Invariant value set using a loop", formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " if (i == ${LOOP_ITERS_PARTIAL})\n" " v_unrelated = value;\n" " }\n" " gl_Position = vec4(value.xyz / ${LOOP_NORM_LITERAL} + a_input.xyz * 0.1, 1.0);\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " }\n" " gl_Position = vec4(value.xyz / ${LOOP_NORM_LITERAL} + a_input.xyz * 0.1, 1.0);\n" "}\n", args))); group->addChild( new BasicInvarianceTest(m_context, "loop_2", "Invariant value set using a loop", formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " v_unrelated = vec4(0.0, 0.0, -1.0, 1.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " if (i == ${LOOP_ITERS_PARTIAL})\n" " gl_Position = a_input + 0.05 * vec4(fract(value.xyz / " "1.0e${LOOP_NORM_FRACT_EXP}), 1.0);\n" " else\n" " v_unrelated = value + a_input;\n" " }\n" "}\n", args), formatGLSL("${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " v_unrelated = vec4(0.0, 0.0, -1.0, 1.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " if (i == ${LOOP_ITERS_PARTIAL})\n" " gl_Position = a_input + 0.05 * vec4(fract(value.xyz / " "1.0e${LOOP_NORM_FRACT_EXP}), 1.0);\n" " else\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " }\n" "}\n", args))); group->addChild(new BasicInvarianceTest( m_context, "loop_3", "Invariant value set using a loop", formatGLSL( "${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " gl_Position += vec4(value.xyz / ${SUM_LOOP_NORM_LITERAL} + a_input.xyz * 0.1, 1.0);\n" " v_unrelated = gl_Position.xyzx * a_input;\n" " }\n" "}\n", args), formatGLSL( "${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 value = a_input;\n" " gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value *= ${LOOP_MULTIPLIER};\n" " gl_Position += vec4(value.xyz / ${SUM_LOOP_NORM_LITERAL} + a_input.xyz * 0.1, 1.0);\n" " }\n" "}\n", args))); group->addChild(new BasicInvarianceTest( m_context, "loop_4", "Invariant value set using a loop", formatGLSL( "${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 position = vec4(0.0, 0.0, 0.0, 0.0);\n" " ${IN_PREC} vec4 value1 = a_input;\n" " ${IN_PREC} vec4 value2 = a_input;\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value1 *= ${LOOP_MULTIPLIER};\n" " v_unrelated = v_unrelated*1.3 + a_input.xyzx * value1.xyxw;\n" " }\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value2 *= ${LOOP_MULTIPLIER};\n" " position = position*1.3 + a_input.xyzx * value2.xyxw;\n" " }\n" " gl_Position = a_input + 0.05 * vec4(fract(position.xyz / 1.0e${LOOP_NORM_FRACT_EXP}), 1.0);\n" "}\n", args), formatGLSL( "${VERSION}" "${IN} ${IN_PREC} vec4 a_input;\n" "${OUT} mediump vec4 v_unrelated;\n" "invariant gl_Position;\n" "void main ()\n" "{\n" " ${IN_PREC} vec4 position = vec4(0.0, 0.0, 0.0, 0.0);\n" " ${IN_PREC} vec4 value2 = a_input;\n" " v_unrelated = vec4(0.0, 0.0, 0.0, 0.0);\n" " for (mediump int i = 0; i < ${LOOP_ITERS}; ++i)\n" " {\n" " value2 *= ${LOOP_MULTIPLIER};\n" " position = position*1.3 + a_input.xyzx * value2.xyxw;\n" " }\n" " gl_Position = a_input + 0.05 * vec4(fract(position.xyz / 1.0e${LOOP_NORM_FRACT_EXP}), 1.0);\n" "}\n", args))); } } } } // namespace Functional } // namespace gles2 } // namespace deqp