| /*------------------------------------------------------------------------- |
| * 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 Rbo state query tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fShaderStateQueryTests.hpp" |
| #include "glsStateQueryUtil.hpp" |
| #include "es3fApiCase.hpp" |
| #include "gluRenderContext.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "deRandom.hpp" |
| #include "deMath.h" |
| #include "deString.h" |
| |
| using namespace glw; // GLint and other GL types |
| using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard; |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| namespace |
| { |
| |
| static const char *commonTestVertSource = "#version 300 es\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(0.0);\n" |
| "}\n\0"; |
| static const char *commonTestFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n\0"; |
| |
| static const char *brokenShader = "#version 300 es\n" |
| "broken, this should not compile!\n" |
| "\n\0"; |
| |
| // rounds x.1 to x+1 |
| template <typename T> |
| T roundGLfloatToNearestIntegerUp(GLfloat val) |
| { |
| return (T)(ceil(val)); |
| } |
| |
| // rounds x.9 to x |
| template <typename T> |
| T roundGLfloatToNearestIntegerDown(GLfloat val) |
| { |
| return (T)(floor(val)); |
| } |
| |
| bool checkIntEquals(tcu::TestContext &testCtx, GLint got, GLint expected) |
| { |
| using tcu::TestLog; |
| |
| if (got != expected) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got |
| << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value"); |
| return false; |
| } |
| return true; |
| } |
| |
| void checkPointerEquals(tcu::TestContext &testCtx, const void *got, const void *expected) |
| { |
| using tcu::TestLog; |
| |
| if (got != expected) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got |
| << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value"); |
| } |
| } |
| |
| void verifyShaderParam(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint shader, GLenum pname, |
| GLenum reference) |
| { |
| StateQueryMemoryWriteGuard<GLint> state; |
| gl.glGetShaderiv(shader, pname, &state); |
| |
| if (state.verifyValidity(testCtx)) |
| checkIntEquals(testCtx, state, reference); |
| } |
| |
| bool verifyProgramParam(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLenum pname, |
| GLenum reference) |
| { |
| StateQueryMemoryWriteGuard<GLint> state; |
| gl.glGetProgramiv(program, pname, &state); |
| |
| return state.verifyValidity(testCtx) && checkIntEquals(testCtx, state, reference); |
| } |
| |
| void verifyActiveUniformParam(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLuint index, |
| GLenum pname, GLenum reference) |
| { |
| StateQueryMemoryWriteGuard<GLint> state; |
| gl.glGetActiveUniformsiv(program, 1, &index, pname, &state); |
| |
| if (state.verifyValidity(testCtx)) |
| checkIntEquals(testCtx, state, reference); |
| } |
| |
| void verifyActiveUniformBlockParam(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, |
| GLuint blockIndex, GLenum pname, GLenum reference) |
| { |
| StateQueryMemoryWriteGuard<GLint> state; |
| gl.glGetActiveUniformBlockiv(program, blockIndex, pname, &state); |
| |
| if (state.verifyValidity(testCtx)) |
| checkIntEquals(testCtx, state, reference); |
| } |
| |
| void verifyCurrentVertexAttribf(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLint index, GLfloat x, GLfloat y, |
| GLfloat z, GLfloat w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[4]> attribValue; |
| gl.glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, attribValue); |
| |
| attribValue.verifyValidity(testCtx); |
| |
| if (attribValue[0] != x || attribValue[1] != y || attribValue[2] != z || attribValue[3] != w) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected [" << x << "," << y << "," << z << "," << w << "];" |
| << "got [" << attribValue[0] << "," << attribValue[1] << "," << attribValue[2] << "," |
| << attribValue[3] << "]" << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid attribute value"); |
| } |
| } |
| |
| void verifyCurrentVertexAttribIi(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLint index, GLint x, GLint y, |
| GLint z, GLint w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint[4]> attribValue; |
| gl.glGetVertexAttribIiv(index, GL_CURRENT_VERTEX_ATTRIB, attribValue); |
| |
| attribValue.verifyValidity(testCtx); |
| |
| if (attribValue[0] != x || attribValue[1] != y || attribValue[2] != z || attribValue[3] != w) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected [" << x << "," << y << "," << z << "," << w << "];" |
| << "got [" << attribValue[0] << "," << attribValue[1] << "," << attribValue[2] << "," |
| << attribValue[3] << "]" << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid attribute value"); |
| } |
| } |
| |
| void verifyCurrentVertexAttribIui(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLint index, GLuint x, GLuint y, |
| GLuint z, GLuint w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLuint[4]> attribValue; |
| gl.glGetVertexAttribIuiv(index, GL_CURRENT_VERTEX_ATTRIB, attribValue); |
| |
| attribValue.verifyValidity(testCtx); |
| |
| if (attribValue[0] != x || attribValue[1] != y || attribValue[2] != z || attribValue[3] != w) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected [" << x << "," << y << "," << z << "," << w << "];" |
| << "got [" << attribValue[0] << "," << attribValue[1] << "," << attribValue[2] << "," |
| << attribValue[3] << "]" << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid attribute value"); |
| } |
| } |
| |
| void verifyCurrentVertexAttribConversion(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLint index, GLfloat x, |
| GLfloat y, GLfloat z, GLfloat w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint[4]> attribValue; |
| gl.glGetVertexAttribiv(index, GL_CURRENT_VERTEX_ATTRIB, attribValue); |
| |
| attribValue.verifyValidity(testCtx); |
| |
| const GLint referenceAsGLintMin[] = { |
| roundGLfloatToNearestIntegerDown<GLint>(x), roundGLfloatToNearestIntegerDown<GLint>(y), |
| roundGLfloatToNearestIntegerDown<GLint>(z), roundGLfloatToNearestIntegerDown<GLint>(w)}; |
| const GLint referenceAsGLintMax[] = { |
| roundGLfloatToNearestIntegerUp<GLint>(x), roundGLfloatToNearestIntegerUp<GLint>(y), |
| roundGLfloatToNearestIntegerUp<GLint>(z), roundGLfloatToNearestIntegerUp<GLint>(w)}; |
| |
| if (attribValue[0] < referenceAsGLintMin[0] || attribValue[0] > referenceAsGLintMax[0] || |
| attribValue[1] < referenceAsGLintMin[1] || attribValue[1] > referenceAsGLintMax[1] || |
| attribValue[2] < referenceAsGLintMin[2] || attribValue[2] > referenceAsGLintMax[2] || |
| attribValue[3] < referenceAsGLintMin[3] || attribValue[3] > referenceAsGLintMax[3]) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected in range " |
| << "[" << referenceAsGLintMin[0] << " " << referenceAsGLintMax[0] << "], " |
| << "[" << referenceAsGLintMin[1] << " " << referenceAsGLintMax[1] << "], " |
| << "[" << referenceAsGLintMin[2] << " " << referenceAsGLintMax[2] << "], " |
| << "[" << referenceAsGLintMin[3] << " " << referenceAsGLintMax[3] << "]" |
| << "; got " << attribValue[0] << ", " << attribValue[1] << ", " << attribValue[2] << ", " |
| << attribValue[3] << " " |
| << "; Input=" << x << "; " << y << "; " << z << "; " << w << " " << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid attribute value"); |
| } |
| } |
| |
| void verifyVertexAttrib(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLint index, GLenum pname, GLenum reference) |
| { |
| StateQueryMemoryWriteGuard<GLint> state; |
| gl.glGetVertexAttribIiv(index, pname, &state); |
| |
| if (state.verifyValidity(testCtx)) |
| checkIntEquals(testCtx, state, reference); |
| } |
| |
| void verifyUniformValue1f(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, float x) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[1]> state; |
| gl.glGetUniformfv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << "]; got [" << state[0] << "]" |
| << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue2f(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, float x, |
| float y) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[2]> state; |
| gl.glGetUniformfv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << "]; got [" << state[0] |
| << ", " << state[1] << "]" << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue3f(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, float x, |
| float y, float z) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[3]> state; |
| gl.glGetUniformfv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y || state[2] != z) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << ", " << z << "]; got [" |
| << state[0] << ", " << state[1] << ", " << state[2] << "]" << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue4f(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, float x, |
| float y, float z, float w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[4]> state; |
| gl.glGetUniformfv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y || state[2] != z || state[3] != w) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << ", " << z << ", " << w |
| << "]; got [" << state[0] << ", " << state[1] << ", " << state[2] << ", " << state[3] << "]" |
| << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue1i(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLint x) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint[1]> state; |
| gl.glGetUniformiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << "]; got [" << state[0] << "]" |
| << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue2i(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLint x, |
| GLint y) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint[2]> state; |
| gl.glGetUniformiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << "]; got [" << state[0] |
| << ", " << state[1] << "]" << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue3i(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLint x, |
| GLint y, GLint z) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint[3]> state; |
| gl.glGetUniformiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y || state[2] != z) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << ", " << z << "]; got [" |
| << state[0] << ", " << state[1] << ", " << state[2] << "]" << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue4i(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLint x, |
| GLint y, GLint z, GLint w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint[4]> state; |
| gl.glGetUniformiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y || state[2] != z || state[3] != w) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << ", " << z << ", " << w |
| << "]; got [" << state[0] << ", " << state[1] << ", " << state[2] << ", " << state[3] << "]" |
| << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue1ui(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLuint x) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLuint[1]> state; |
| gl.glGetUniformuiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << "]; got [" << state[0] << "]" |
| << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue2ui(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLuint x, |
| GLuint y) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLuint[2]> state; |
| gl.glGetUniformuiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << "]; got [" << state[0] |
| << ", " << state[1] << "]" << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue3ui(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLuint x, |
| GLuint y, GLuint z) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLuint[3]> state; |
| gl.glGetUniformuiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y || state[2] != z) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << ", " << z << "]; got [" |
| << state[0] << ", " << state[1] << ", " << state[2] << "]" << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| void verifyUniformValue4ui(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, GLuint x, |
| GLuint y, GLuint z, GLuint w) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLuint[4]> state; |
| gl.glGetUniformuiv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state[0] != x || state[1] != y || state[2] != z || state[3] != w) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected [" << x << ", " << y << ", " << z << ", " << w |
| << "]; got [" << state[0] << ", " << state[1] << ", " << state[2] << ", " << state[3] << "]" |
| << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| |
| template <int Count> |
| void verifyUniformValues(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, |
| const GLfloat *values) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[Count]> state; |
| gl.glGetUniformfv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| for (int ndx = 0; ndx < Count; ++ndx) |
| { |
| if (values[ndx] != state[ndx]) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: at index " << ndx << " expected " << values[ndx] |
| << "; got " << state[ndx] << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| } |
| |
| template <int N> |
| void verifyUniformMatrixValues(tcu::TestContext &testCtx, glu::CallLogWrapper &gl, GLuint program, GLint location, |
| const GLfloat *values, bool transpose) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLfloat[N * N]> state; |
| gl.glGetUniformfv(program, location, state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| for (int y = 0; y < N; ++y) |
| for (int x = 0; x < N; ++x) |
| { |
| const int refIndex = y * N + x; |
| const int stateIndex = transpose ? (x * N + y) : (y * N + x); |
| |
| if (values[refIndex] != state[stateIndex]) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: at index [" << y << "][" << x << "] expected " |
| << values[refIndex] << "; got " << state[stateIndex] << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid uniform value"); |
| } |
| } |
| } |
| |
| class ShaderTypeCase : public ApiCase |
| { |
| public: |
| ShaderTypeCase(Context &context, const char *name, const char *description) : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const GLenum shaderTypes[] = {GL_VERTEX_SHADER, GL_FRAGMENT_SHADER}; |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ++ndx) |
| { |
| const GLuint shader = glCreateShader(shaderTypes[ndx]); |
| verifyShaderParam(m_testCtx, *this, shader, GL_SHADER_TYPE, shaderTypes[ndx]); |
| glDeleteShader(shader); |
| } |
| } |
| }; |
| |
| class ShaderCompileStatusCase : public ApiCase |
| { |
| public: |
| ShaderCompileStatusCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_FALSE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_FALSE); |
| |
| glShaderSource(shaderVert, 1, &commonTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &commonTestFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_TRUE); |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ShaderInfoLogCase : public ApiCase |
| { |
| public: |
| ShaderInfoLogCase(Context &context, const char *name, const char *description) : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| // INFO_LOG_LENGTH is 0 by default and it includes null-terminator |
| const GLuint shader = glCreateShader(GL_VERTEX_SHADER); |
| verifyShaderParam(m_testCtx, *this, shader, GL_INFO_LOG_LENGTH, 0); |
| |
| glShaderSource(shader, 1, &brokenShader, DE_NULL); |
| glCompileShader(shader); |
| expectError(GL_NO_ERROR); |
| |
| // check the log length |
| StateQueryMemoryWriteGuard<GLint> logLength; |
| glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength); |
| if (!logLength.verifyValidity(m_testCtx)) |
| { |
| glDeleteShader(shader); |
| return; |
| } |
| if (logLength == 0) |
| { |
| glDeleteShader(shader); |
| return; |
| } |
| |
| // check normal case |
| { |
| char buffer[2048] = {'x'}; // non-zero initialization |
| |
| GLint written = 0; // written does not include null terminator |
| glGetShaderInfoLog(shader, DE_LENGTH_OF_ARRAY(buffer), &written, buffer); |
| |
| // check lengths are consistent |
| if (logLength <= DE_LENGTH_OF_ARRAY(buffer)) |
| { |
| if (written != logLength - 1) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected length " << logLength - 1 << "; got " |
| << written << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log length"); |
| } |
| } |
| |
| // check null-terminator, either at end of buffer or at buffer[written] |
| const char *terminator = &buffer[DE_LENGTH_OF_ARRAY(buffer) - 1]; |
| if (logLength < DE_LENGTH_OF_ARRAY(buffer)) |
| terminator = &buffer[written]; |
| |
| if (*terminator != '\0') |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected null terminator, got " << (int)*terminator |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log terminator"); |
| } |
| } |
| |
| // check with too small buffer |
| { |
| char buffer[2048] = {'x'}; // non-zero initialization |
| |
| // check string always ends with \0, even with small buffers |
| GLint written = 0; |
| glGetShaderInfoLog(shader, 1, &written, buffer); |
| if (written != 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected length 0; got " << written |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log length"); |
| } |
| if (buffer[0] != '\0') |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected null terminator, got " << (int)buffer[0] |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log terminator"); |
| } |
| } |
| |
| glDeleteShader(shader); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ShaderSourceCase : public ApiCase |
| { |
| public: |
| ShaderSourceCase(Context &context, const char *name, const char *description) : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| // SHADER_SOURCE_LENGTH does include 0-terminator |
| const GLuint shader = glCreateShader(GL_VERTEX_SHADER); |
| verifyShaderParam(m_testCtx, *this, shader, GL_SHADER_SOURCE_LENGTH, 0); |
| |
| // check the SHADER_SOURCE_LENGTH |
| { |
| glShaderSource(shader, 1, &brokenShader, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| StateQueryMemoryWriteGuard<GLint> sourceLength; |
| glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &sourceLength); |
| |
| sourceLength.verifyValidity(m_testCtx); |
| |
| const GLint referenceLength = |
| (GLint)std::string(brokenShader).length() + 1; // including the null terminator |
| if (sourceLength != referenceLength) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected length " << referenceLength << "; got " |
| << sourceLength << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid source length"); |
| } |
| } |
| |
| // check the concat source SHADER_SOURCE_LENGTH |
| { |
| const char *shaders[] = {brokenShader, brokenShader}; |
| glShaderSource(shader, 2, shaders, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| StateQueryMemoryWriteGuard<GLint> sourceLength; |
| glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &sourceLength); |
| |
| sourceLength.verifyValidity(m_testCtx); |
| |
| const GLint referenceLength = |
| 2 * (GLint)std::string(brokenShader).length() + 1; // including the null terminator |
| if (sourceLength != referenceLength) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected length " << referenceLength << "; got " |
| << sourceLength << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid source length"); |
| } |
| } |
| |
| // check the string length |
| { |
| char buffer[2048] = {'x'}; |
| DE_ASSERT(DE_LENGTH_OF_ARRAY(buffer) > 2 * (int)std::string(brokenShader).length()); |
| |
| GLint written = 0; // not inluding null-terminator |
| glGetShaderSource(shader, DE_LENGTH_OF_ARRAY(buffer), &written, buffer); |
| |
| const GLint referenceLength = 2 * (GLint)std::string(brokenShader).length(); |
| if (written != referenceLength) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected write length " << referenceLength |
| << "; got " << written << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid source length"); |
| } |
| // check null pointer at |
| else |
| { |
| if (buffer[referenceLength] != '\0') |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected null terminator at " |
| << referenceLength << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "did not get a null terminator"); |
| } |
| } |
| } |
| |
| // check with small buffer |
| { |
| char buffer[2048] = {'x'}; |
| |
| GLint written = 0; |
| glGetShaderSource(shader, 1, &written, buffer); |
| |
| if (written != 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected write length 0; got " << written |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid source length"); |
| } |
| if (buffer[0] != '\0') |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected null terminator; got=" << int(buffer[0]) |
| << ", char=" << buffer[0] << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid terminator"); |
| } |
| } |
| |
| glDeleteShader(shader); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class DeleteStatusCase : public ApiCase |
| { |
| public: |
| DeleteStatusCase(Context &context, const char *name, const char *description) : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &commonTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &commonTestFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_TRUE); |
| |
| GLuint shaderProg = glCreateProgram(); |
| glAttachShader(shaderProg, shaderVert); |
| glAttachShader(shaderProg, shaderFrag); |
| glLinkProgram(shaderProg); |
| expectError(GL_NO_ERROR); |
| |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_LINK_STATUS, GL_TRUE); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_DELETE_STATUS, GL_FALSE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_DELETE_STATUS, GL_FALSE); |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_DELETE_STATUS, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| glUseProgram(shaderProg); |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(shaderProg); |
| expectError(GL_NO_ERROR); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_DELETE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_DELETE_STATUS, GL_TRUE); |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_DELETE_STATUS, GL_TRUE); |
| expectError(GL_NO_ERROR); |
| |
| glUseProgram(0); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class CurrentVertexAttribInitialCase : public ApiCase |
| { |
| public: |
| CurrentVertexAttribInitialCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| int attribute_count = 16; |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribute_count); |
| |
| // initial |
| |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| StateQueryMemoryWriteGuard<GLfloat[4]> attribValue; |
| glGetVertexAttribfv(index, GL_CURRENT_VERTEX_ATTRIB, attribValue); |
| attribValue.verifyValidity(m_testCtx); |
| |
| if (attribValue[0] != 0.0f || attribValue[1] != 0.0f || attribValue[2] != 0.0f || attribValue[3] != 1.0f) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected [0, 0, 0, 1];" |
| << "got [" << attribValue[0] << "," << attribValue[1] << "," << attribValue[2] << "," |
| << attribValue[3] << "]" << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid attribute value"); |
| } |
| } |
| } |
| }; |
| |
| class CurrentVertexAttribFloatCase : public ApiCase |
| { |
| public: |
| CurrentVertexAttribFloatCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| de::Random rnd(0xabcdef); |
| |
| int attribute_count = 16; |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribute_count); |
| |
| // test write float/read float |
| |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = rnd.getFloat(-64000, 64000); |
| const GLfloat z = rnd.getFloat(-64000, 64000); |
| const GLfloat w = rnd.getFloat(-64000, 64000); |
| |
| glVertexAttrib4f(index, x, y, z, w); |
| verifyCurrentVertexAttribf(m_testCtx, *this, index, x, y, z, w); |
| } |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = rnd.getFloat(-64000, 64000); |
| const GLfloat z = rnd.getFloat(-64000, 64000); |
| const GLfloat w = 1.0f; |
| |
| glVertexAttrib3f(index, x, y, z); |
| verifyCurrentVertexAttribf(m_testCtx, *this, index, x, y, z, w); |
| } |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = rnd.getFloat(-64000, 64000); |
| const GLfloat z = 0.0f; |
| const GLfloat w = 1.0f; |
| |
| glVertexAttrib2f(index, x, y); |
| verifyCurrentVertexAttribf(m_testCtx, *this, index, x, y, z, w); |
| } |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = 0.0f; |
| const GLfloat z = 0.0f; |
| const GLfloat w = 1.0f; |
| |
| glVertexAttrib1f(index, x); |
| verifyCurrentVertexAttribf(m_testCtx, *this, index, x, y, z, w); |
| } |
| } |
| }; |
| |
| class CurrentVertexAttribIntCase : public ApiCase |
| { |
| public: |
| CurrentVertexAttribIntCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| de::Random rnd(0xabcdef); |
| |
| int attribute_count = 16; |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribute_count); |
| |
| // test write float/read float |
| |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLint x = rnd.getInt(-64000, 64000); |
| const GLint y = rnd.getInt(-64000, 64000); |
| const GLint z = rnd.getInt(-64000, 64000); |
| const GLint w = rnd.getInt(-64000, 64000); |
| |
| glVertexAttribI4i(index, x, y, z, w); |
| verifyCurrentVertexAttribIi(m_testCtx, *this, index, x, y, z, w); |
| } |
| } |
| }; |
| |
| class CurrentVertexAttribUintCase : public ApiCase |
| { |
| public: |
| CurrentVertexAttribUintCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| de::Random rnd(0xabcdef); |
| |
| int attribute_count = 16; |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribute_count); |
| |
| // test write float/read float |
| |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLuint x = rnd.getInt(0, 64000); |
| const GLuint y = rnd.getInt(0, 64000); |
| const GLuint z = rnd.getInt(0, 64000); |
| const GLuint w = rnd.getInt(0, 64000); |
| |
| glVertexAttribI4ui(index, x, y, z, w); |
| verifyCurrentVertexAttribIui(m_testCtx, *this, index, x, y, z, w); |
| } |
| } |
| }; |
| |
| class CurrentVertexAttribConversionCase : public ApiCase |
| { |
| public: |
| CurrentVertexAttribConversionCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| de::Random rnd(0xabcdef); |
| |
| int attribute_count = 16; |
| glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribute_count); |
| |
| // test write float/read float |
| |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = rnd.getFloat(-64000, 64000); |
| const GLfloat z = rnd.getFloat(-64000, 64000); |
| const GLfloat w = rnd.getFloat(-64000, 64000); |
| |
| glVertexAttrib4f(index, x, y, z, w); |
| verifyCurrentVertexAttribConversion(m_testCtx, *this, index, x, y, z, w); |
| } |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = rnd.getFloat(-64000, 64000); |
| const GLfloat z = rnd.getFloat(-64000, 64000); |
| const GLfloat w = 1.0f; |
| |
| glVertexAttrib3f(index, x, y, z); |
| verifyCurrentVertexAttribConversion(m_testCtx, *this, index, x, y, z, w); |
| } |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = rnd.getFloat(-64000, 64000); |
| const GLfloat z = 0.0f; |
| const GLfloat w = 1.0f; |
| |
| glVertexAttrib2f(index, x, y); |
| verifyCurrentVertexAttribConversion(m_testCtx, *this, index, x, y, z, w); |
| } |
| for (int index = 0; index < attribute_count; ++index) |
| { |
| const GLfloat x = rnd.getFloat(-64000, 64000); |
| const GLfloat y = 0.0f; |
| const GLfloat z = 0.0f; |
| const GLfloat w = 1.0f; |
| |
| glVertexAttrib1f(index, x); |
| verifyCurrentVertexAttribConversion(m_testCtx, *this, index, x, y, z, w); |
| } |
| } |
| }; |
| |
| class ProgramInfoLogCase : public ApiCase |
| { |
| public: |
| enum BuildErrorType |
| { |
| BUILDERROR_COMPILE = 0, |
| BUILDERROR_LINK |
| }; |
| |
| ProgramInfoLogCase(Context &context, const char *name, const char *description, BuildErrorType buildErrorType) |
| : ApiCase(context, name, description) |
| , m_buildErrorType(buildErrorType) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| enum |
| { |
| BUF_SIZE = 2048 |
| }; |
| |
| static const char *const linkErrorVtxSource = "#version 300 es\n" |
| "in highp vec4 a_pos;\n" |
| "uniform highp vec4 u_uniform;\n" |
| "void main ()\n" |
| "{\n" |
| " gl_Position = a_pos + u_uniform;\n" |
| "}\n"; |
| static const char *const linkErrorFrgSource = "#version 300 es\n" |
| "in highp vec4 v_missingVar;\n" |
| "uniform highp int u_uniform;\n" |
| "layout(location = 0) out mediump vec4 fragColor;\n" |
| "void main ()\n" |
| "{\n" |
| " fragColor = v_missingVar + vec4(float(u_uniform));\n" |
| "}\n"; |
| |
| const char *vtxSource = (m_buildErrorType == BUILDERROR_COMPILE) ? (brokenShader) : (linkErrorVtxSource); |
| const char *frgSource = (m_buildErrorType == BUILDERROR_COMPILE) ? (brokenShader) : (linkErrorFrgSource); |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &vtxSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &frgSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| |
| StateQueryMemoryWriteGuard<GLint> logLength; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength); |
| logLength.verifyValidity(m_testCtx); |
| |
| // check INFO_LOG_LENGTH == GetProgramInfoLog len |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "QueryLarge", "Query to large buffer"); |
| char buffer[BUF_SIZE] = {'x'}; |
| GLint written = 0; |
| |
| glGetProgramInfoLog(program, BUF_SIZE, &written, buffer); |
| |
| if (logLength != 0 && written + 1 != logLength) // INFO_LOG_LENGTH contains 0-terminator |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected INFO_LOG_LENGTH " << written + 1 |
| << "; got " << logLength << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log length"); |
| } |
| else if (logLength != 0 && buffer[written] != '\0') |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected null terminator at index " << written |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "missing null terminator"); |
| } |
| } |
| |
| // check query to just correct sized buffer |
| if (BUF_SIZE > logLength) |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "QueryAll", |
| "Query all to exactly right sized buffer"); |
| char buffer[BUF_SIZE] = {'x'}; |
| GLint written = 0; |
| |
| glGetProgramInfoLog(program, logLength, &written, buffer); |
| |
| if (logLength != 0 && written + 1 != logLength) // INFO_LOG_LENGTH contains 0-terminator |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected INFO_LOG_LENGTH " << written + 1 |
| << "; got " << logLength << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log length"); |
| } |
| else if (logLength != 0 && buffer[written] != '\0') |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected null terminator at index " << written |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "missing null terminator"); |
| } |
| } |
| |
| // check GetProgramInfoLog works with too small buffer |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "QueryNone", "Query none"); |
| char buffer[BUF_SIZE] = {'x'}; |
| GLint written = 0; |
| |
| glGetProgramInfoLog(program, 1, &written, buffer); |
| |
| if (written != 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected write length 0; got " << written |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid log length"); |
| } |
| } |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| |
| const BuildErrorType m_buildErrorType; |
| }; |
| |
| class ProgramValidateStatusCase : public ApiCase |
| { |
| public: |
| ProgramValidateStatusCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| // test validate ok |
| { |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &commonTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &commonTestFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_TRUE); |
| verifyProgramParam(m_testCtx, *this, program, GL_LINK_STATUS, GL_TRUE); |
| |
| glValidateProgram(program); |
| verifyProgramParam(m_testCtx, *this, program, GL_VALIDATE_STATUS, GL_TRUE); |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| |
| // test with broken shader |
| { |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &commonTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &brokenShader, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_FALSE); |
| verifyProgramParam(m_testCtx, *this, program, GL_LINK_STATUS, GL_FALSE); |
| |
| glValidateProgram(program); |
| verifyProgramParam(m_testCtx, *this, program, GL_VALIDATE_STATUS, GL_FALSE); |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class ProgramAttachedShadersCase : public ApiCase |
| { |
| public: |
| ProgramAttachedShadersCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &commonTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &commonTestFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| // check ATTACHED_SHADERS |
| |
| GLuint program = glCreateProgram(); |
| verifyProgramParam(m_testCtx, *this, program, GL_ATTACHED_SHADERS, 0); |
| expectError(GL_NO_ERROR); |
| |
| glAttachShader(program, shaderVert); |
| verifyProgramParam(m_testCtx, *this, program, GL_ATTACHED_SHADERS, 1); |
| expectError(GL_NO_ERROR); |
| |
| glAttachShader(program, shaderFrag); |
| verifyProgramParam(m_testCtx, *this, program, GL_ATTACHED_SHADERS, 2); |
| expectError(GL_NO_ERROR); |
| |
| // check GetAttachedShaders |
| { |
| GLuint shaders[2] = {0, 0}; |
| GLint count = 0; |
| glGetAttachedShaders(program, DE_LENGTH_OF_ARRAY(shaders), &count, shaders); |
| |
| if (count != 2) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected 2; got " << count << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong shader count"); |
| } |
| // shaders are the attached shaders? |
| if (!((shaders[0] == shaderVert && shaders[1] == shaderFrag) || |
| (shaders[0] == shaderFrag && shaders[1] == shaderVert))) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected {" << shaderVert << ", " << shaderFrag |
| << "}; got {" << shaders[0] << ", " << shaders[1] << "}" << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong shader count"); |
| } |
| } |
| |
| // check GetAttachedShaders with too small buffer |
| { |
| GLuint shaders[2] = {0, 0}; |
| GLint count = 0; |
| |
| glGetAttachedShaders(program, 0, &count, shaders); |
| if (count != 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected 0; got " << count << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong shader count"); |
| } |
| |
| count = 0; |
| glGetAttachedShaders(program, 1, &count, shaders); |
| if (count != 1) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected 1; got " << count << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong shader count"); |
| } |
| } |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ProgramActiveUniformNameCase : public ApiCase |
| { |
| public: |
| ProgramActiveUniformNameCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| static const char *testVertSource = "#version 300 es\n" |
| "uniform highp float uniformNameWithLength23;\n" |
| "uniform highp vec2 uniformVec2;\n" |
| "uniform highp mat4 uniformMat4;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(0.0) + vec4(uniformNameWithLength23) + " |
| "vec4(uniformVec2.x) + vec4(uniformMat4[2][3]);\n" |
| "}\n\0"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n\0"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| verifyProgramParam(m_testCtx, *this, program, GL_ACTIVE_UNIFORMS, 3); |
| verifyProgramParam(m_testCtx, *this, program, GL_ACTIVE_UNIFORM_MAX_LENGTH, |
| (GLint)std::string("uniformNameWithLength23").length() + 1); // including a null terminator |
| expectError(GL_NO_ERROR); |
| |
| const char *uniformNames[] = {"uniformNameWithLength23", "uniformVec2", "uniformMat4"}; |
| StateQueryMemoryWriteGuard<GLuint[DE_LENGTH_OF_ARRAY(uniformNames)]> uniformIndices; |
| glGetUniformIndices(program, DE_LENGTH_OF_ARRAY(uniformNames), uniformNames, uniformIndices); |
| uniformIndices.verifyValidity(m_testCtx); |
| |
| // check name lengths |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uniformNames); ++ndx) |
| { |
| const GLuint uniformIndex = uniformIndices[ndx]; |
| |
| StateQueryMemoryWriteGuard<GLint> uniformNameLen; |
| glGetActiveUniformsiv(program, 1, &uniformIndex, GL_UNIFORM_NAME_LENGTH, &uniformNameLen); |
| |
| uniformNameLen.verifyValidity(m_testCtx); |
| |
| const GLint referenceLength = (GLint)std::string(uniformNames[ndx]).length() + 1; |
| if (referenceLength != uniformNameLen) // uniformNameLen is with null terminator |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << referenceLength << "got " |
| << uniformNameLen << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong uniform name length"); |
| } |
| } |
| |
| // check names |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uniformNames); ++ndx) |
| { |
| char buffer[2048] = {'x'}; |
| |
| const GLuint uniformIndex = uniformIndices[ndx]; |
| |
| GLint written = 0; // null terminator not included |
| GLint size = 0; |
| GLenum type = 0; |
| glGetActiveUniform(program, uniformIndex, DE_LENGTH_OF_ARRAY(buffer), &written, &size, &type, buffer); |
| |
| const GLint referenceLength = (GLint)std::string(uniformNames[ndx]).length(); |
| if (referenceLength != written) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << referenceLength << "got " << written |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong uniform name length"); |
| } |
| |
| // and with too small buffer |
| written = 0; |
| glGetActiveUniform(program, uniformIndex, 1, &written, &size, &type, buffer); |
| |
| if (written != 0) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected 0 got " << written << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong uniform name length"); |
| } |
| } |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ProgramUniformCase : public ApiCase |
| { |
| public: |
| ProgramUniformCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const struct UniformType |
| { |
| const char *declaration; |
| const char *postDeclaration; |
| const char *precision; |
| const char *layout; |
| const char *getter; |
| GLenum type; |
| GLint size; |
| GLint isRowMajor; |
| } uniformTypes[] = { |
| {"float", "", "highp", "", "uniformValue", GL_FLOAT, 1, GL_FALSE}, |
| {"float[2]", "", "highp", "", "uniformValue[1]", GL_FLOAT, 2, GL_FALSE}, |
| {"vec2", "", "highp", "", "uniformValue.x", GL_FLOAT_VEC2, 1, GL_FALSE}, |
| {"vec3", "", "highp", "", "uniformValue.x", GL_FLOAT_VEC3, 1, GL_FALSE}, |
| {"vec4", "", "highp", "", "uniformValue.x", GL_FLOAT_VEC4, 1, GL_FALSE}, |
| {"int", "", "highp", "", "float(uniformValue)", GL_INT, 1, GL_FALSE}, |
| {"ivec2", "", "highp", "", "float(uniformValue.x)", GL_INT_VEC2, 1, GL_FALSE}, |
| {"ivec3", "", "highp", "", "float(uniformValue.x)", GL_INT_VEC3, 1, GL_FALSE}, |
| {"ivec4", "", "highp", "", "float(uniformValue.x)", GL_INT_VEC4, 1, GL_FALSE}, |
| {"uint", "", "highp", "", "float(uniformValue)", GL_UNSIGNED_INT, 1, GL_FALSE}, |
| {"uvec2", "", "highp", "", "float(uniformValue.x)", GL_UNSIGNED_INT_VEC2, 1, GL_FALSE}, |
| {"uvec3", "", "highp", "", "float(uniformValue.x)", GL_UNSIGNED_INT_VEC3, 1, GL_FALSE}, |
| {"uvec4", "", "highp", "", "float(uniformValue.x)", GL_UNSIGNED_INT_VEC4, 1, GL_FALSE}, |
| {"bool", "", "", "", "float(uniformValue)", GL_BOOL, 1, GL_FALSE}, |
| {"bvec2", "", "", "", "float(uniformValue.x)", GL_BOOL_VEC2, 1, GL_FALSE}, |
| {"bvec3", "", "", "", "float(uniformValue.x)", GL_BOOL_VEC3, 1, GL_FALSE}, |
| {"bvec4", "", "", "", "float(uniformValue.x)", GL_BOOL_VEC4, 1, GL_FALSE}, |
| {"mat2", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT2, 1, GL_FALSE}, |
| {"mat3", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT3, 1, GL_FALSE}, |
| {"mat4", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT4, 1, GL_FALSE}, |
| {"mat2x3", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT2x3, 1, GL_FALSE}, |
| {"mat2x4", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT2x4, 1, GL_FALSE}, |
| {"mat3x2", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT3x2, 1, GL_FALSE}, |
| {"mat3x4", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT3x4, 1, GL_FALSE}, |
| {"mat4x2", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT4x2, 1, GL_FALSE}, |
| {"mat4x3", "", "highp", "", "float(uniformValue[0][0])", GL_FLOAT_MAT4x3, 1, GL_FALSE}, |
| {"sampler2D", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_SAMPLER_2D, 1, GL_FALSE}, |
| {"sampler3D", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_SAMPLER_3D, 1, GL_FALSE}, |
| {"samplerCube", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_SAMPLER_CUBE, 1, GL_FALSE}, |
| {"sampler2DShadow", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_SAMPLER_2D_SHADOW, 1, |
| GL_FALSE}, |
| {"sampler2DArray", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_SAMPLER_2D_ARRAY, 1, |
| GL_FALSE}, |
| {"sampler2DArrayShadow", "", "highp", "", "float(textureSize(uniformValue,0).r)", |
| GL_SAMPLER_2D_ARRAY_SHADOW, 1, GL_FALSE}, |
| {"samplerCubeShadow", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_SAMPLER_CUBE_SHADOW, 1, |
| GL_FALSE}, |
| {"isampler2D", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_INT_SAMPLER_2D, 1, GL_FALSE}, |
| {"isampler3D", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_INT_SAMPLER_3D, 1, GL_FALSE}, |
| {"isamplerCube", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_INT_SAMPLER_CUBE, 1, GL_FALSE}, |
| {"isampler2DArray", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_INT_SAMPLER_2D_ARRAY, 1, |
| GL_FALSE}, |
| {"usampler2D", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_UNSIGNED_INT_SAMPLER_2D, 1, |
| GL_FALSE}, |
| {"usampler3D", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_UNSIGNED_INT_SAMPLER_3D, 1, |
| GL_FALSE}, |
| {"usamplerCube", "", "highp", "", "float(textureSize(uniformValue,0).r)", GL_UNSIGNED_INT_SAMPLER_CUBE, 1, |
| GL_FALSE}, |
| {"usampler2DArray", "", "highp", "", "float(textureSize(uniformValue,0).r)", |
| GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, 1, GL_FALSE}, |
| }; |
| |
| static const char *vertSource = "#version 300 es\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(0.0);\n" |
| "}\n\0"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| GLuint program = glCreateProgram(); |
| |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| |
| glShaderSource(shaderVert, 1, &vertSource, DE_NULL); |
| glCompileShader(shaderVert); |
| expectError(GL_NO_ERROR); |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uniformTypes); ++ndx) |
| { |
| tcu::ScopedLogSection(m_log, uniformTypes[ndx].declaration, |
| std::string("Verify type of ") + uniformTypes[ndx].declaration + " variable" + |
| uniformTypes[ndx].postDeclaration); |
| |
| // gen fragment shader |
| |
| std::ostringstream frag; |
| frag << "#version 300 es\n"; |
| frag << uniformTypes[ndx].layout << "uniform " << uniformTypes[ndx].precision << " " |
| << uniformTypes[ndx].declaration << " uniformValue" << uniformTypes[ndx].postDeclaration << ";\n"; |
| frag << "layout(location = 0) out mediump vec4 fragColor;\n"; |
| frag << "void main (void)\n"; |
| frag << "{\n"; |
| frag << " fragColor = vec4(" << uniformTypes[ndx].getter << ");\n"; |
| frag << "}\n"; |
| |
| { |
| std::string fragmentSource = frag.str(); |
| const char *fragmentSourceCStr = fragmentSource.c_str(); |
| glShaderSource(shaderFrag, 1, &fragmentSourceCStr, DE_NULL); |
| } |
| |
| // compile & link |
| |
| glCompileShader(shaderFrag); |
| glLinkProgram(program); |
| |
| // test |
| if (verifyProgramParam(m_testCtx, *this, program, GL_LINK_STATUS, GL_TRUE)) |
| { |
| const char *uniformNames[] = {"uniformValue"}; |
| StateQueryMemoryWriteGuard<GLuint> uniformIndex; |
| glGetUniformIndices(program, 1, uniformNames, &uniformIndex); |
| uniformIndex.verifyValidity(m_testCtx); |
| |
| verifyActiveUniformParam(m_testCtx, *this, program, uniformIndex, GL_UNIFORM_TYPE, |
| uniformTypes[ndx].type); |
| verifyActiveUniformParam(m_testCtx, *this, program, uniformIndex, GL_UNIFORM_SIZE, |
| uniformTypes[ndx].size); |
| verifyActiveUniformParam(m_testCtx, *this, program, uniformIndex, GL_UNIFORM_IS_ROW_MAJOR, |
| uniformTypes[ndx].isRowMajor); |
| } |
| } |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ProgramActiveUniformBlocksCase : public ApiCase |
| { |
| public: |
| ProgramActiveUniformBlocksCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| static const char *testVertSource = |
| "#version 300 es\n" |
| "uniform longlongUniformBlockName {highp vec2 vector2;} longlongUniformInstanceName;\n" |
| "uniform shortUniformBlockName {highp vec2 vector2;highp vec4 vector4;} shortUniformInstanceName;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = shortUniformInstanceName.vector4 + vec4(longlongUniformInstanceName.vector2.x) + " |
| "vec4(shortUniformInstanceName.vector2.x);\n" |
| "}\n\0"; |
| static const char *testFragSource = |
| "#version 300 es\n" |
| "uniform longlongUniformBlockName {highp vec2 vector2;} longlongUniformInstanceName;\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(longlongUniformInstanceName.vector2.y);\n" |
| "}\n\0"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_TRUE); |
| verifyProgramParam(m_testCtx, *this, program, GL_LINK_STATUS, GL_TRUE); |
| |
| verifyProgramParam(m_testCtx, *this, program, GL_ACTIVE_UNIFORM_BLOCKS, 2); |
| verifyProgramParam(m_testCtx, *this, program, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, |
| (GLint)std::string("longlongUniformBlockName").length() + 1); // including a null terminator |
| expectError(GL_NO_ERROR); |
| |
| GLint longlongUniformBlockIndex = glGetUniformBlockIndex(program, "longlongUniformBlockName"); |
| GLint shortUniformBlockIndex = glGetUniformBlockIndex(program, "shortUniformBlockName"); |
| |
| const char *uniformNames[] = {"longlongUniformBlockName.vector2", "shortUniformBlockName.vector2", |
| "shortUniformBlockName.vector4"}; |
| |
| // test UNIFORM_BLOCK_INDEX |
| |
| DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(uniformNames) == 3); |
| |
| StateQueryMemoryWriteGuard<GLuint[DE_LENGTH_OF_ARRAY(uniformNames)]> uniformIndices; |
| StateQueryMemoryWriteGuard<GLint[DE_LENGTH_OF_ARRAY(uniformNames)]> uniformsBlockIndices; |
| |
| glGetUniformIndices(program, DE_LENGTH_OF_ARRAY(uniformNames), uniformNames, uniformIndices); |
| uniformIndices.verifyValidity(m_testCtx); |
| expectError(GL_NO_ERROR); |
| |
| glGetActiveUniformsiv(program, DE_LENGTH_OF_ARRAY(uniformNames), uniformIndices, GL_UNIFORM_BLOCK_INDEX, |
| uniformsBlockIndices); |
| uniformsBlockIndices.verifyValidity(m_testCtx); |
| expectError(GL_NO_ERROR); |
| |
| if (uniformsBlockIndices[0] != longlongUniformBlockIndex || uniformsBlockIndices[1] != shortUniformBlockIndex || |
| uniformsBlockIndices[2] != shortUniformBlockIndex) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected [" << longlongUniformBlockIndex << ", " |
| << shortUniformBlockIndex << ", " << shortUniformBlockIndex << "];" |
| << "got [" << uniformsBlockIndices[0] << ", " << uniformsBlockIndices[1] << ", " |
| << uniformsBlockIndices[2] << "]" << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong uniform block index"); |
| } |
| |
| // test UNIFORM_BLOCK_NAME_LENGTH |
| |
| verifyActiveUniformBlockParam( |
| m_testCtx, *this, program, longlongUniformBlockIndex, GL_UNIFORM_BLOCK_NAME_LENGTH, |
| (GLint)std::string("longlongUniformBlockName").length() + 1); // including null-terminator |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, shortUniformBlockIndex, GL_UNIFORM_BLOCK_NAME_LENGTH, |
| (GLint)std::string("shortUniformBlockName").length() + |
| 1); // including null-terminator |
| expectError(GL_NO_ERROR); |
| |
| // test UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER & UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER |
| |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, longlongUniformBlockIndex, |
| GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, GL_TRUE); |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, longlongUniformBlockIndex, |
| GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, GL_TRUE); |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, shortUniformBlockIndex, |
| GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, GL_TRUE); |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, shortUniformBlockIndex, |
| GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| // test UNIFORM_BLOCK_ACTIVE_UNIFORMS |
| |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, longlongUniformBlockIndex, |
| GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, 1); |
| verifyActiveUniformBlockParam(m_testCtx, *this, program, shortUniformBlockIndex, |
| GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, 2); |
| expectError(GL_NO_ERROR); |
| |
| // test UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES |
| |
| { |
| StateQueryMemoryWriteGuard<GLint> longlongUniformBlockUniforms; |
| glGetActiveUniformBlockiv(program, longlongUniformBlockIndex, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, |
| &longlongUniformBlockUniforms); |
| longlongUniformBlockUniforms.verifyValidity(m_testCtx); |
| |
| if (longlongUniformBlockUniforms == 2) |
| { |
| StateQueryMemoryWriteGuard<GLint[2]> longlongUniformBlockUniformIndices; |
| glGetActiveUniformBlockiv(program, longlongUniformBlockIndex, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, |
| longlongUniformBlockUniformIndices); |
| longlongUniformBlockUniformIndices.verifyValidity(m_testCtx); |
| |
| if ((GLuint(longlongUniformBlockUniformIndices[0]) != uniformIndices[0] || |
| GLuint(longlongUniformBlockUniformIndices[1]) != uniformIndices[1]) && |
| (GLuint(longlongUniformBlockUniformIndices[1]) != uniformIndices[0] || |
| GLuint(longlongUniformBlockUniformIndices[0]) != uniformIndices[1])) |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Expected {" << uniformIndices[0] << ", " |
| << uniformIndices[1] << "};" |
| << "got {" << longlongUniformBlockUniformIndices[0] << ", " |
| << longlongUniformBlockUniformIndices[1] << "}" << TestLog::EndMessage; |
| |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got wrong uniform indices"); |
| } |
| } |
| } |
| |
| // check block names |
| |
| { |
| char buffer[2048] = {'x'}; |
| GLint written = 0; |
| glGetActiveUniformBlockName(program, longlongUniformBlockIndex, DE_LENGTH_OF_ARRAY(buffer), &written, |
| buffer); |
| checkIntEquals(m_testCtx, written, (GLint)std::string("longlongUniformBlockName").length()); |
| |
| written = 0; |
| glGetActiveUniformBlockName(program, shortUniformBlockIndex, DE_LENGTH_OF_ARRAY(buffer), &written, buffer); |
| checkIntEquals(m_testCtx, written, (GLint)std::string("shortUniformBlockName").length()); |
| |
| // and one with too small buffer |
| written = 0; |
| glGetActiveUniformBlockName(program, longlongUniformBlockIndex, 1, &written, buffer); |
| checkIntEquals(m_testCtx, written, 0); |
| } |
| |
| expectError(GL_NO_ERROR); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ProgramBinaryCase : public ApiCase |
| { |
| public: |
| ProgramBinaryCase(Context &context, const char *name, const char *description) : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &commonTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &commonTestFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| // test PROGRAM_BINARY_RETRIEVABLE_HINT |
| verifyProgramParam(m_testCtx, *this, program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_FALSE); |
| |
| glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE); |
| expectError(GL_NO_ERROR); |
| |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| verifyProgramParam(m_testCtx, *this, program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE); |
| |
| // test PROGRAM_BINARY_LENGTH does something |
| |
| StateQueryMemoryWriteGuard<GLint> programLength; |
| glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &programLength); |
| expectError(GL_NO_ERROR); |
| programLength.verifyValidity(m_testCtx); |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class TransformFeedbackCase : public ApiCase |
| { |
| public: |
| TransformFeedbackCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| static const char *transformFeedbackTestVertSource = "#version 300 es\n" |
| "out highp vec4 tfOutput2withLongName;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(0.0);\n" |
| " tfOutput2withLongName = vec4(0.0);\n" |
| "}\n"; |
| static const char *transformFeedbackTestFragSource = "#version 300 es\n" |
| "layout(location = 0) out highp vec4 fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| GLuint shaderProg = glCreateProgram(); |
| |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, GL_INTERLEAVED_ATTRIBS); |
| |
| glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| |
| verifyShaderParam(m_testCtx, *this, shaderVert, GL_COMPILE_STATUS, GL_TRUE); |
| verifyShaderParam(m_testCtx, *this, shaderFrag, GL_COMPILE_STATUS, GL_TRUE); |
| |
| glAttachShader(shaderProg, shaderVert); |
| glAttachShader(shaderProg, shaderFrag); |
| |
| // check TRANSFORM_FEEDBACK_BUFFER_MODE |
| |
| const char *transform_feedback_outputs[] = {"gl_Position", "tfOutput2withLongName"}; |
| const char *longest_output = transform_feedback_outputs[1]; |
| const GLenum bufferModes[] = {GL_SEPARATE_ATTRIBS, GL_INTERLEAVED_ATTRIBS}; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(bufferModes); ++ndx) |
| { |
| glTransformFeedbackVaryings(shaderProg, DE_LENGTH_OF_ARRAY(transform_feedback_outputs), |
| transform_feedback_outputs, bufferModes[ndx]); |
| glLinkProgram(shaderProg); |
| expectError(GL_NO_ERROR); |
| |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_LINK_STATUS, GL_TRUE); |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, bufferModes[ndx]); |
| } |
| |
| // TRANSFORM_FEEDBACK_VARYINGS |
| verifyProgramParam(m_testCtx, *this, shaderProg, GL_TRANSFORM_FEEDBACK_VARYINGS, 2); |
| |
| // TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH |
| { |
| StateQueryMemoryWriteGuard<GLint> maxOutputLen; |
| glGetProgramiv(shaderProg, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &maxOutputLen); |
| |
| maxOutputLen.verifyValidity(m_testCtx); |
| |
| const GLint referenceLength = (GLint)std::string(longest_output).length() + 1; |
| checkIntEquals(m_testCtx, maxOutputLen, referenceLength); |
| } |
| |
| // check varyings |
| { |
| StateQueryMemoryWriteGuard<GLint> varyings; |
| glGetProgramiv(shaderProg, GL_TRANSFORM_FEEDBACK_VARYINGS, &varyings); |
| |
| if (!varyings.isUndefined()) |
| for (int index = 0; index < varyings; ++index) |
| { |
| char buffer[2048] = {'x'}; |
| |
| GLint written = 0; |
| GLint size = 0; |
| GLenum type = 0; |
| glGetTransformFeedbackVarying(shaderProg, index, DE_LENGTH_OF_ARRAY(buffer), &written, &size, &type, |
| buffer); |
| |
| if (written < DE_LENGTH_OF_ARRAY(buffer) && buffer[written] != '\0') |
| { |
| m_testCtx.getLog() |
| << TestLog::Message << "// ERROR: Expected null terminator" << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid string terminator"); |
| } |
| |
| // check with too small buffer |
| written = 0; |
| glGetTransformFeedbackVarying(shaderProg, index, 1, &written, &size, &type, buffer); |
| if (written != 0) |
| { |
| m_testCtx.getLog() |
| << TestLog::Message << "// ERROR: Expected 0; got " << written << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid write length"); |
| } |
| } |
| } |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(shaderProg); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class ActiveAttributesCase : public ApiCase |
| { |
| public: |
| ActiveAttributesCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| using tcu::TestLog; |
| |
| static const char *testVertSource = "#version 300 es\n" |
| "in highp vec2 longInputAttributeName;\n" |
| "in highp vec2 shortName;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = longInputAttributeName.yxxy + shortName.xyxy;\n" |
| "}\n\0"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n\0"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| verifyProgramParam(m_testCtx, *this, program, GL_ACTIVE_ATTRIBUTES, 2); |
| verifyProgramParam(m_testCtx, *this, program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, |
| (GLint)std::string("longInputAttributeName").length() + 1); // does include null-terminator |
| |
| // check names |
| for (int attributeNdx = 0; attributeNdx < 2; ++attributeNdx) |
| { |
| char buffer[2048] = {'x'}; |
| |
| GLint written = 0; |
| GLint size = 0; |
| GLenum type = 0; |
| glGetActiveAttrib(program, attributeNdx, DE_LENGTH_OF_ARRAY(buffer), &written, &size, &type, buffer); |
| expectError(GL_NO_ERROR); |
| |
| if (deStringBeginsWith(buffer, "longInputAttributeName")) |
| { |
| checkIntEquals( |
| m_testCtx, written, |
| (GLint)std::string("longInputAttributeName").length()); // does NOT include null-terminator |
| } |
| else if (deStringBeginsWith(buffer, "shortName")) |
| { |
| checkIntEquals(m_testCtx, written, |
| (GLint)std::string("shortName").length()); // does NOT include null-terminator |
| } |
| else |
| { |
| m_testCtx.getLog() << TestLog::Message << "// ERROR: Got unexpected attribute name." |
| << TestLog::EndMessage; |
| if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected name"); |
| } |
| } |
| |
| // and with too short buffer |
| { |
| char buffer[2048] = {'x'}; |
| |
| GLint written = 0; |
| GLint size = 0; |
| GLenum type = 0; |
| |
| glGetActiveAttrib(program, 0, 1, &written, &size, &type, buffer); |
| expectError(GL_NO_ERROR); |
| checkIntEquals(m_testCtx, written, 0); |
| } |
| |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| struct PointerData |
| { |
| GLint size; |
| GLenum type; |
| GLint stride; |
| GLboolean normalized; |
| const void *pointer; |
| }; |
| |
| class VertexAttributeSizeCase : public ApiCase |
| { |
| public: |
| VertexAttributeSizeCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| GLfloat vertexData[4] = {0.0f}; // never accessed |
| |
| const PointerData pointers[] = { |
| // size test |
| {4, GL_FLOAT, 0, GL_FALSE, vertexData}, {3, GL_FLOAT, 0, GL_FALSE, vertexData}, |
| {2, GL_FLOAT, 0, GL_FALSE, vertexData}, {1, GL_FLOAT, 0, GL_FALSE, vertexData}, |
| {4, GL_INT, 0, GL_FALSE, vertexData}, {3, GL_INT, 0, GL_FALSE, vertexData}, |
| {2, GL_INT, 0, GL_FALSE, vertexData}, {1, GL_INT, 0, GL_FALSE, vertexData}, |
| }; |
| |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].normalized, |
| pointers[ndx].stride, pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_SIZE, pointers[ndx].size); |
| } |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint buf = 0; |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| glGenBuffers(1, &buf); |
| glBindBuffer(GL_ARRAY_BUFFER, buf); |
| expectError(GL_NO_ERROR); |
| |
| // initial |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_SIZE, 4); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glVertexAttribPointer(0, pointers[0].size, pointers[0].type, pointers[0].normalized, pointers[0].stride, |
| DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glVertexAttribPointer(0, pointers[1].size, pointers[1].type, pointers[1].normalized, pointers[1].stride, |
| DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_SIZE, pointers[1].size); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_SIZE, pointers[0].size); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(1, &buf); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeTypeCase : public ApiCase |
| { |
| public: |
| VertexAttributeTypeCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| const GLfloat vertexData[4] = {0.0f}; // never accessed |
| |
| // test VertexAttribPointer |
| { |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_INT, 0, GL_FALSE, vertexData}, |
| {1, GL_FIXED, 0, GL_FALSE, vertexData}, |
| {1, GL_FLOAT, 0, GL_FALSE, vertexData}, |
| {1, GL_HALF_FLOAT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_FALSE, vertexData}, |
| {4, GL_INT_2_10_10_10_REV, 0, GL_FALSE, vertexData}, |
| {4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, GL_FALSE, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].normalized, |
| pointers[ndx].stride, pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_TYPE, pointers[ndx].type); |
| } |
| } |
| |
| // test glVertexAttribIPointer |
| { |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_INT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_FALSE, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribIPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].stride, |
| pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_TYPE, pointers[ndx].type); |
| } |
| } |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint buf = 0; |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| glGenBuffers(1, &buf); |
| glBindBuffer(GL_ARRAY_BUFFER, buf); |
| expectError(GL_NO_ERROR); |
| |
| // initial |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_FLOAT); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glVertexAttribPointer(0, 1, GL_SHORT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_SHORT); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_FLOAT); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(1, &buf); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeStrideCase : public ApiCase |
| { |
| public: |
| VertexAttributeStrideCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| const GLfloat vertexData[4] = {0.0f}; // never accessed |
| |
| struct StridePointerData |
| { |
| GLint size; |
| GLenum type; |
| GLint stride; |
| const void *pointer; |
| }; |
| |
| // test VertexAttribPointer |
| { |
| const StridePointerData pointers[] = { |
| {1, GL_FLOAT, 0, vertexData}, {1, GL_FLOAT, 1, vertexData}, |
| {1, GL_FLOAT, 4, vertexData}, {1, GL_HALF_FLOAT, 0, vertexData}, |
| {1, GL_HALF_FLOAT, 1, vertexData}, {1, GL_HALF_FLOAT, 4, vertexData}, |
| {1, GL_FIXED, 0, vertexData}, {1, GL_FIXED, 1, vertexData}, |
| {1, GL_FIXED, 4, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribPointer(0, pointers[ndx].size, pointers[ndx].type, GL_FALSE, pointers[ndx].stride, |
| pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, pointers[ndx].stride); |
| } |
| } |
| |
| // test glVertexAttribIPointer |
| { |
| const StridePointerData pointers[] = { |
| {1, GL_INT, 0, vertexData}, {1, GL_INT, 1, vertexData}, |
| {1, GL_INT, 4, vertexData}, {4, GL_UNSIGNED_BYTE, 0, vertexData}, |
| {4, GL_UNSIGNED_BYTE, 1, vertexData}, {4, GL_UNSIGNED_BYTE, 4, vertexData}, |
| {2, GL_SHORT, 0, vertexData}, {2, GL_SHORT, 1, vertexData}, |
| {2, GL_SHORT, 4, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribIPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].stride, |
| pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, pointers[ndx].stride); |
| } |
| } |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint buf = 0; |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| glGenBuffers(1, &buf); |
| glBindBuffer(GL_ARRAY_BUFFER, buf); |
| expectError(GL_NO_ERROR); |
| |
| // initial |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, 0); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 4, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glVertexAttribPointer(0, 1, GL_SHORT, GL_FALSE, 8, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, 8); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, 4); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(1, &buf); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeNormalizedCase : public ApiCase |
| { |
| public: |
| VertexAttributeNormalizedCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| const GLfloat vertexData[4] = {0.0f}; // never accessed |
| |
| // test VertexAttribPointer |
| { |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_INT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_FALSE, vertexData}, |
| {4, GL_INT_2_10_10_10_REV, 0, GL_FALSE, vertexData}, |
| {4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, GL_FALSE, vertexData}, |
| {1, GL_BYTE, 0, GL_TRUE, vertexData}, |
| {1, GL_SHORT, 0, GL_TRUE, vertexData}, |
| {1, GL_INT, 0, GL_TRUE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_TRUE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_TRUE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_TRUE, vertexData}, |
| {4, GL_INT_2_10_10_10_REV, 0, GL_TRUE, vertexData}, |
| {4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, GL_TRUE, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].normalized, |
| pointers[ndx].stride, pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, |
| pointers[ndx].normalized); |
| } |
| } |
| |
| // test glVertexAttribIPointer |
| { |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_INT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_FALSE, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribIPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].stride, |
| pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_FALSE); |
| } |
| } |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint buf = 0; |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| glGenBuffers(1, &buf); |
| glBindBuffer(GL_ARRAY_BUFFER, buf); |
| expectError(GL_NO_ERROR); |
| |
| // initial |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glVertexAttribPointer(0, 1, GL_INT, GL_TRUE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glVertexAttribPointer(0, 1, GL_INT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_TRUE); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(1, &buf); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeIntegerCase : public ApiCase |
| { |
| public: |
| VertexAttributeIntegerCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| const GLfloat vertexData[4] = {0.0f}; // never accessed |
| |
| // test VertexAttribPointer |
| { |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_INT, 0, GL_FALSE, vertexData}, |
| {1, GL_FIXED, 0, GL_FALSE, vertexData}, |
| {1, GL_FLOAT, 0, GL_FALSE, vertexData}, |
| {1, GL_HALF_FLOAT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_FALSE, vertexData}, |
| {4, GL_INT_2_10_10_10_REV, 0, GL_FALSE, vertexData}, |
| {4, GL_UNSIGNED_INT_2_10_10_10_REV, 0, GL_FALSE, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].normalized, |
| pointers[ndx].stride, pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_FALSE); |
| } |
| } |
| |
| // test glVertexAttribIPointer |
| { |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_INT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_BYTE, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_SHORT, 0, GL_FALSE, vertexData}, |
| {1, GL_UNSIGNED_INT, 0, GL_FALSE, vertexData}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribIPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].stride, |
| pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_TRUE); |
| } |
| } |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint buf = 0; |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| glGenBuffers(1, &buf); |
| glBindBuffer(GL_ARRAY_BUFFER, buf); |
| expectError(GL_NO_ERROR); |
| |
| // initial |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glVertexAttribIPointer(0, 1, GL_INT, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_TRUE); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(1, &buf); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeEnabledCase : public ApiCase |
| { |
| public: |
| VertexAttributeEnabledCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| // VERTEX_ATTRIB_ARRAY_ENABLED |
| |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_FALSE); |
| glEnableVertexAttribArray(0); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_TRUE); |
| glDisableVertexAttribArray(0); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_FALSE); |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glBindVertexArray(vaos[0]); |
| glEnableVertexAttribArray(0); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glDisableVertexAttribArray(0); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_FALSE); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_TRUE); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeDivisorCase : public ApiCase |
| { |
| public: |
| VertexAttributeDivisorCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 0); |
| glVertexAttribDivisor(0, 1); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 1); |
| glVertexAttribDivisor(0, 5); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 5); |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint vaos[2] = {0}; |
| |
| glGenVertexArrays(2, vaos); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glBindVertexArray(vaos[0]); |
| glVertexAttribDivisor(0, 1); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glVertexAttribDivisor(0, 5); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 5); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 1); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributeBufferBindingCase : public ApiCase |
| { |
| public: |
| VertexAttributeBufferBindingCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| // initial |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, 0); |
| |
| GLuint bufferID; |
| glGenBuffers(1, &bufferID); |
| glBindBuffer(GL_ARRAY_BUFFER, bufferID); |
| expectError(GL_NO_ERROR); |
| |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, bufferID); |
| |
| glDeleteBuffers(1, &bufferID); |
| expectError(GL_NO_ERROR); |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint vaos[2] = {0}; |
| GLuint bufs[2] = {0}; |
| |
| glGenBuffers(2, bufs); |
| expectError(GL_NO_ERROR); |
| |
| glGenVertexArrays(2, vaos); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glBindVertexArray(vaos[0]); |
| glBindBuffer(GL_ARRAY_BUFFER, bufs[0]); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glBindBuffer(GL_ARRAY_BUFFER, bufs[1]); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, bufs[1]); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| verifyVertexAttrib(m_testCtx, *this, 0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, bufs[0]); |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(2, bufs); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class VertexAttributePointerCase : public ApiCase |
| { |
| public: |
| VertexAttributePointerCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| const glu::ContextType &contextType = m_context.getRenderContext().getType(); |
| const bool isCoreGL45 = glu::contextSupports(contextType, glu::ApiType::core(4, 5)); |
| |
| // Test with default VAO |
| if (!isCoreGL45) |
| { |
| const tcu::ScopedLogSection section(m_log, "DefaultVAO", "Test with default VAO"); |
| |
| StateQueryMemoryWriteGuard<GLvoid *> initialState; |
| glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &initialState); |
| initialState.verifyValidity(m_testCtx); |
| checkPointerEquals(m_testCtx, initialState, 0); |
| |
| const GLfloat vertexData[4] = {0.0f}; // never accessed |
| const PointerData pointers[] = { |
| {1, GL_BYTE, 0, GL_FALSE, &vertexData[2]}, {1, GL_SHORT, 0, GL_FALSE, &vertexData[1]}, |
| {1, GL_INT, 0, GL_FALSE, &vertexData[2]}, {1, GL_FIXED, 0, GL_FALSE, &vertexData[2]}, |
| {1, GL_FIXED, 0, GL_FALSE, &vertexData[1]}, {1, GL_FLOAT, 0, GL_FALSE, &vertexData[0]}, |
| {1, GL_FLOAT, 0, GL_FALSE, &vertexData[3]}, {1, GL_FLOAT, 0, GL_FALSE, &vertexData[2]}, |
| {1, GL_HALF_FLOAT, 0, GL_FALSE, &vertexData[0]}, {4, GL_HALF_FLOAT, 0, GL_FALSE, &vertexData[1]}, |
| {4, GL_HALF_FLOAT, 0, GL_FALSE, &vertexData[2]}, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(pointers); ++ndx) |
| { |
| glVertexAttribPointer(0, pointers[ndx].size, pointers[ndx].type, pointers[ndx].normalized, |
| pointers[ndx].stride, pointers[ndx].pointer); |
| expectError(GL_NO_ERROR); |
| |
| StateQueryMemoryWriteGuard<GLvoid *> state; |
| glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &state); |
| state.verifyValidity(m_testCtx); |
| checkPointerEquals(m_testCtx, state, pointers[ndx].pointer); |
| } |
| } |
| |
| // Test with multiple VAOs |
| { |
| const tcu::ScopedLogSection section(m_log, "WithVAO", "Test with VAO"); |
| |
| GLuint vaos[2] = {0}; |
| GLuint bufs[2] = {0}; |
| |
| glGenBuffers(2, bufs); |
| expectError(GL_NO_ERROR); |
| |
| glGenVertexArrays(2, vaos); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 0 to some value |
| glBindVertexArray(vaos[0]); |
| glBindBuffer(GL_ARRAY_BUFFER, bufs[0]); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, glu::BufferOffsetAsPointer(8)); |
| expectError(GL_NO_ERROR); |
| |
| // set vao 1 to some other value |
| glBindVertexArray(vaos[1]); |
| glBindBuffer(GL_ARRAY_BUFFER, bufs[1]); |
| glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, glu::BufferOffsetAsPointer(4)); |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 1 state |
| { |
| StateQueryMemoryWriteGuard<GLvoid *> state; |
| glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &state); |
| state.verifyValidity(m_testCtx); |
| checkPointerEquals(m_testCtx, state, glu::BufferOffsetAsPointer(4)); |
| } |
| expectError(GL_NO_ERROR); |
| |
| // verify vao 0 state |
| glBindVertexArray(vaos[0]); |
| { |
| StateQueryMemoryWriteGuard<GLvoid *> state; |
| glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &state); |
| state.verifyValidity(m_testCtx); |
| checkPointerEquals(m_testCtx, state, glu::BufferOffsetAsPointer(8)); |
| } |
| expectError(GL_NO_ERROR); |
| |
| glDeleteVertexArrays(2, vaos); |
| glDeleteBuffers(2, bufs); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class UniformValueFloatCase : public ApiCase |
| { |
| public: |
| UniformValueFloatCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = |
| "#version 300 es\n" |
| "uniform highp float floatUniform;\n" |
| "uniform highp vec2 float2Uniform;\n" |
| "uniform highp vec3 float3Uniform;\n" |
| "uniform highp vec4 float4Uniform;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(floatUniform + float2Uniform.x + float3Uniform.x + float4Uniform.x);\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| location = glGetUniformLocation(program, "floatUniform"); |
| glUniform1f(location, 1.0f); |
| verifyUniformValue1f(m_testCtx, *this, program, location, 1.0f); |
| |
| location = glGetUniformLocation(program, "float2Uniform"); |
| glUniform2f(location, 1.0f, 2.0f); |
| verifyUniformValue2f(m_testCtx, *this, program, location, 1.0f, 2.0f); |
| |
| location = glGetUniformLocation(program, "float3Uniform"); |
| glUniform3f(location, 1.0f, 2.0f, 3.0f); |
| verifyUniformValue3f(m_testCtx, *this, program, location, 1.0f, 2.0f, 3.0f); |
| |
| location = glGetUniformLocation(program, "float4Uniform"); |
| glUniform4f(location, 1.0f, 2.0f, 3.0f, 4.0f); |
| verifyUniformValue4f(m_testCtx, *this, program, location, 1.0f, 2.0f, 3.0f, 4.0f); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class UniformValueIntCase : public ApiCase |
| { |
| public: |
| UniformValueIntCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = |
| "#version 300 es\n" |
| "uniform highp int intUniform;\n" |
| "uniform highp ivec2 int2Uniform;\n" |
| "uniform highp ivec3 int3Uniform;\n" |
| "uniform highp ivec4 int4Uniform;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(float(intUniform + int2Uniform.x + int3Uniform.x + int4Uniform.x));\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| location = glGetUniformLocation(program, "intUniform"); |
| glUniform1i(location, 1); |
| verifyUniformValue1i(m_testCtx, *this, program, location, 1); |
| |
| location = glGetUniformLocation(program, "int2Uniform"); |
| glUniform2i(location, 1, 2); |
| verifyUniformValue2i(m_testCtx, *this, program, location, 1, 2); |
| |
| location = glGetUniformLocation(program, "int3Uniform"); |
| glUniform3i(location, 1, 2, 3); |
| verifyUniformValue3i(m_testCtx, *this, program, location, 1, 2, 3); |
| |
| location = glGetUniformLocation(program, "int4Uniform"); |
| glUniform4i(location, 1, 2, 3, 4); |
| verifyUniformValue4i(m_testCtx, *this, program, location, 1, 2, 3, 4); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class UniformValueUintCase : public ApiCase |
| { |
| public: |
| UniformValueUintCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = |
| "#version 300 es\n" |
| "uniform highp uint uintUniform;\n" |
| "uniform highp uvec2 uint2Uniform;\n" |
| "uniform highp uvec3 uint3Uniform;\n" |
| "uniform highp uvec4 uint4Uniform;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(float(uintUniform + uint2Uniform.x + uint3Uniform.x + uint4Uniform.x));\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| location = glGetUniformLocation(program, "uintUniform"); |
| glUniform1ui(location, 1); |
| verifyUniformValue1ui(m_testCtx, *this, program, location, 1); |
| |
| location = glGetUniformLocation(program, "uint2Uniform"); |
| glUniform2ui(location, 1, 2); |
| verifyUniformValue2ui(m_testCtx, *this, program, location, 1, 2); |
| |
| location = glGetUniformLocation(program, "uint3Uniform"); |
| glUniform3ui(location, 1, 2, 3); |
| verifyUniformValue3ui(m_testCtx, *this, program, location, 1, 2, 3); |
| |
| location = glGetUniformLocation(program, "uint4Uniform"); |
| glUniform4ui(location, 1, 2, 3, 4); |
| verifyUniformValue4ui(m_testCtx, *this, program, location, 1, 2, 3, 4); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class UniformValueBooleanCase : public ApiCase |
| { |
| public: |
| UniformValueBooleanCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = "#version 300 es\n" |
| "uniform bool boolUniform;\n" |
| "uniform bvec2 bool2Uniform;\n" |
| "uniform bvec3 bool3Uniform;\n" |
| "uniform bvec4 bool4Uniform;\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(float(boolUniform) + float(bool2Uniform.x) + " |
| "float(bool3Uniform.x) + float(bool4Uniform.x));\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| // int conversion |
| |
| location = glGetUniformLocation(program, "boolUniform"); |
| glUniform1i(location, 1); |
| verifyUniformValue1i(m_testCtx, *this, program, location, 1); |
| |
| location = glGetUniformLocation(program, "bool2Uniform"); |
| glUniform2i(location, 1, 2); |
| verifyUniformValue2i(m_testCtx, *this, program, location, 1, 1); |
| |
| location = glGetUniformLocation(program, "bool3Uniform"); |
| glUniform3i(location, 0, 1, 2); |
| verifyUniformValue3i(m_testCtx, *this, program, location, 0, 1, 1); |
| |
| location = glGetUniformLocation(program, "bool4Uniform"); |
| glUniform4i(location, 1, 0, 1, -1); |
| verifyUniformValue4i(m_testCtx, *this, program, location, 1, 0, 1, 1); |
| |
| // float conversion |
| |
| location = glGetUniformLocation(program, "boolUniform"); |
| glUniform1f(location, 1.0f); |
| verifyUniformValue1i(m_testCtx, *this, program, location, 1); |
| |
| location = glGetUniformLocation(program, "bool2Uniform"); |
| glUniform2f(location, 1.0f, 0.1f); |
| verifyUniformValue2i(m_testCtx, *this, program, location, 1, 1); |
| |
| location = glGetUniformLocation(program, "bool3Uniform"); |
| glUniform3f(location, 0.0f, 0.1f, -0.1f); |
| verifyUniformValue3i(m_testCtx, *this, program, location, 0, 1, 1); |
| |
| location = glGetUniformLocation(program, "bool4Uniform"); |
| glUniform4f(location, 1.0f, 0.0f, 0.1f, -0.9f); |
| verifyUniformValue4i(m_testCtx, *this, program, location, 1, 0, 1, 1); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class UniformValueSamplerCase : public ApiCase |
| { |
| public: |
| UniformValueSamplerCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = "#version 300 es\n" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(0.0);\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "uniform highp sampler2D uniformSampler;\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(textureSize(uniformSampler, 0).x);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| location = glGetUniformLocation(program, "uniformSampler"); |
| glUniform1i(location, 1); |
| verifyUniformValue1i(m_testCtx, *this, program, location, 1); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class UniformValueArrayCase : public ApiCase |
| { |
| public: |
| UniformValueArrayCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = "#version 300 es\n" |
| "uniform highp float arrayUniform[5];" |
| "uniform highp vec2 array2Uniform[5];" |
| "uniform highp vec3 array3Uniform[5];" |
| "uniform highp vec4 array4Uniform[5];" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = \n" |
| " + vec4(arrayUniform[0] + arrayUniform[1] + " |
| "arrayUniform[2] + arrayUniform[3] + arrayUniform[4])\n" |
| " + vec4(array2Uniform[0].x + array2Uniform[1].x + " |
| "array2Uniform[2].x + array2Uniform[3].x + array2Uniform[4].x)\n" |
| " + vec4(array3Uniform[0].x + array3Uniform[1].x + " |
| "array3Uniform[2].x + array3Uniform[3].x + array3Uniform[4].x)\n" |
| " + vec4(array4Uniform[0].x + array4Uniform[1].x + " |
| "array4Uniform[2].x + array4Uniform[3].x + array4Uniform[4].x);\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| float uniformValue[5 * 4] = {-1.0f, 0.1f, 4.0f, 800.0f, 13.0f, 55.0f, 12.0f, 91.0f, -55.1f, 1.1f, |
| 98.0f, 19.0f, 41.0f, 65.0f, 4.0f, 12.2f, 95.0f, 77.0f, 32.0f, 48.0f}; |
| |
| location = glGetUniformLocation(program, "arrayUniform"); |
| glUniform1fv(location, 5, uniformValue); |
| expectError(GL_NO_ERROR); |
| |
| verifyUniformValue1f(m_testCtx, *this, program, glGetUniformLocation(program, "arrayUniform[0]"), |
| uniformValue[0]); |
| verifyUniformValue1f(m_testCtx, *this, program, glGetUniformLocation(program, "arrayUniform[1]"), |
| uniformValue[1]); |
| verifyUniformValue1f(m_testCtx, *this, program, glGetUniformLocation(program, "arrayUniform[2]"), |
| uniformValue[2]); |
| verifyUniformValue1f(m_testCtx, *this, program, glGetUniformLocation(program, "arrayUniform[3]"), |
| uniformValue[3]); |
| verifyUniformValue1f(m_testCtx, *this, program, glGetUniformLocation(program, "arrayUniform[4]"), |
| uniformValue[4]); |
| expectError(GL_NO_ERROR); |
| |
| location = glGetUniformLocation(program, "array2Uniform"); |
| glUniform2fv(location, 5, uniformValue); |
| expectError(GL_NO_ERROR); |
| |
| verifyUniformValue2f(m_testCtx, *this, program, glGetUniformLocation(program, "array2Uniform[0]"), |
| uniformValue[2 * 0], uniformValue[(2 * 0) + 1]); |
| verifyUniformValue2f(m_testCtx, *this, program, glGetUniformLocation(program, "array2Uniform[1]"), |
| uniformValue[2 * 1], uniformValue[(2 * 1) + 1]); |
| verifyUniformValue2f(m_testCtx, *this, program, glGetUniformLocation(program, "array2Uniform[2]"), |
| uniformValue[2 * 2], uniformValue[(2 * 2) + 1]); |
| verifyUniformValue2f(m_testCtx, *this, program, glGetUniformLocation(program, "array2Uniform[3]"), |
| uniformValue[2 * 3], uniformValue[(2 * 3) + 1]); |
| verifyUniformValue2f(m_testCtx, *this, program, glGetUniformLocation(program, "array2Uniform[4]"), |
| uniformValue[2 * 4], uniformValue[(2 * 4) + 1]); |
| expectError(GL_NO_ERROR); |
| |
| location = glGetUniformLocation(program, "array3Uniform"); |
| glUniform3fv(location, 5, uniformValue); |
| expectError(GL_NO_ERROR); |
| |
| verifyUniformValue3f(m_testCtx, *this, program, glGetUniformLocation(program, "array3Uniform[0]"), |
| uniformValue[3 * 0], uniformValue[(3 * 0) + 1], uniformValue[(3 * 0) + 2]); |
| verifyUniformValue3f(m_testCtx, *this, program, glGetUniformLocation(program, "array3Uniform[1]"), |
| uniformValue[3 * 1], uniformValue[(3 * 1) + 1], uniformValue[(3 * 1) + 2]); |
| verifyUniformValue3f(m_testCtx, *this, program, glGetUniformLocation(program, "array3Uniform[2]"), |
| uniformValue[3 * 2], uniformValue[(3 * 2) + 1], uniformValue[(3 * 2) + 2]); |
| verifyUniformValue3f(m_testCtx, *this, program, glGetUniformLocation(program, "array3Uniform[3]"), |
| uniformValue[3 * 3], uniformValue[(3 * 3) + 1], uniformValue[(3 * 3) + 2]); |
| verifyUniformValue3f(m_testCtx, *this, program, glGetUniformLocation(program, "array3Uniform[4]"), |
| uniformValue[3 * 4], uniformValue[(3 * 4) + 1], uniformValue[(3 * 4) + 2]); |
| expectError(GL_NO_ERROR); |
| |
| location = glGetUniformLocation(program, "array4Uniform"); |
| glUniform4fv(location, 5, uniformValue); |
| expectError(GL_NO_ERROR); |
| |
| verifyUniformValue4f(m_testCtx, *this, program, glGetUniformLocation(program, "array4Uniform[0]"), |
| uniformValue[4 * 0], uniformValue[(4 * 0) + 1], uniformValue[(4 * 0) + 2], |
| uniformValue[(4 * 0) + 3]); |
| verifyUniformValue4f(m_testCtx, *this, program, glGetUniformLocation(program, "array4Uniform[1]"), |
| uniformValue[4 * 1], uniformValue[(4 * 1) + 1], uniformValue[(4 * 1) + 2], |
| uniformValue[(4 * 1) + 3]); |
| verifyUniformValue4f(m_testCtx, *this, program, glGetUniformLocation(program, "array4Uniform[2]"), |
| uniformValue[4 * 2], uniformValue[(4 * 2) + 1], uniformValue[(4 * 2) + 2], |
| uniformValue[(4 * 2) + 3]); |
| verifyUniformValue4f(m_testCtx, *this, program, glGetUniformLocation(program, "array4Uniform[3]"), |
| uniformValue[4 * 3], uniformValue[(4 * 3) + 1], uniformValue[(4 * 3) + 2], |
| uniformValue[(4 * 3) + 3]); |
| verifyUniformValue4f(m_testCtx, *this, program, glGetUniformLocation(program, "array4Uniform[4]"), |
| uniformValue[4 * 4], uniformValue[(4 * 4) + 1], uniformValue[(4 * 4) + 2], |
| uniformValue[(4 * 4) + 3]); |
| expectError(GL_NO_ERROR); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class UniformValueMatrixCase : public ApiCase |
| { |
| public: |
| UniformValueMatrixCase(Context &context, const char *name, const char *description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test(void) |
| { |
| static const char *testVertSource = |
| "#version 300 es\n" |
| "uniform highp mat2 mat2Uniform;" |
| "uniform highp mat3 mat3Uniform;" |
| "uniform highp mat4 mat4Uniform;" |
| "void main (void)\n" |
| "{\n" |
| " gl_Position = vec4(mat2Uniform[0][0] + mat3Uniform[0][0] + mat4Uniform[0][0]);\n" |
| "}\n"; |
| static const char *testFragSource = "#version 300 es\n" |
| "layout(location = 0) out mediump vec4 fragColor;" |
| "void main (void)\n" |
| "{\n" |
| " fragColor = vec4(0.0);\n" |
| "}\n"; |
| |
| GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER); |
| GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| glShaderSource(shaderVert, 1, &testVertSource, DE_NULL); |
| glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL); |
| |
| glCompileShader(shaderVert); |
| glCompileShader(shaderFrag); |
| expectError(GL_NO_ERROR); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, shaderVert); |
| glAttachShader(program, shaderFrag); |
| glLinkProgram(program); |
| glUseProgram(program); |
| expectError(GL_NO_ERROR); |
| |
| GLint location; |
| |
| float matrixValues[4 * 4] = { |
| -1.0f, 0.1f, 4.0f, 800.0f, 13.0f, 55.0f, 12.0f, 91.0f, |
| -55.1f, 1.1f, 98.0f, 19.0f, 41.0f, 65.0f, 4.0f, 12.2f, |
| }; |
| |
| // the values of the matrix are returned in column major order but they can be given in either order |
| |
| location = glGetUniformLocation(program, "mat2Uniform"); |
| glUniformMatrix2fv(location, 1, GL_FALSE, matrixValues); |
| verifyUniformMatrixValues<2>(m_testCtx, *this, program, location, matrixValues, false); |
| glUniformMatrix2fv(location, 1, GL_TRUE, matrixValues); |
| verifyUniformMatrixValues<2>(m_testCtx, *this, program, location, matrixValues, true); |
| |
| location = glGetUniformLocation(program, "mat3Uniform"); |
| glUniformMatrix3fv(location, 1, GL_FALSE, matrixValues); |
| verifyUniformMatrixValues<3>(m_testCtx, *this, program, location, matrixValues, false); |
| glUniformMatrix3fv(location, 1, GL_TRUE, matrixValues); |
| verifyUniformMatrixValues<3>(m_testCtx, *this, program, location, matrixValues, true); |
| |
| location = glGetUniformLocation(program, "mat4Uniform"); |
| glUniformMatrix4fv(location, 1, GL_FALSE, matrixValues); |
| verifyUniformMatrixValues<4>(m_testCtx, *this, program, location, matrixValues, false); |
| glUniformMatrix4fv(location, 1, GL_TRUE, matrixValues); |
| verifyUniformMatrixValues<4>(m_testCtx, *this, program, location, matrixValues, true); |
| |
| glUseProgram(0); |
| glDeleteShader(shaderVert); |
| glDeleteShader(shaderFrag); |
| glDeleteProgram(program); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class PrecisionFormatCase : public ApiCase |
| { |
| public: |
| struct RequiredFormat |
| { |
| int negativeRange; |
| int positiveRange; |
| int precision; |
| }; |
| |
| PrecisionFormatCase(Context &context, const char *name, const char *description, glw::GLenum shaderType, |
| glw::GLenum precisionType) |
| : ApiCase(context, name, description) |
| , m_shaderType(shaderType) |
| , m_precisionType(precisionType) |
| { |
| } |
| |
| private: |
| void test(void) |
| { |
| const RequiredFormat expected = getRequiredFormat(); |
| bool error = false; |
| gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLboolean> shaderCompiler; |
| gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint[2]> range; |
| gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint> precision; |
| |
| // query values |
| glGetShaderPrecisionFormat(m_shaderType, m_precisionType, range, &precision); |
| expectError(GL_NO_ERROR); |
| |
| if (!range.verifyValidity(m_testCtx)) |
| return; |
| if (!precision.verifyValidity(m_testCtx)) |
| return; |
| |
| m_log << tcu::TestLog::Message << "range[0] = " << range[0] << "\n" |
| << "range[1] = " << range[1] << "\n" |
| << "precision = " << precision << tcu::TestLog::EndMessage; |
| |
| // verify values |
| |
| if (m_precisionType == GL_HIGH_FLOAT) |
| { |
| // highp float must be IEEE 754 single |
| |
| if (range[0] != expected.negativeRange || range[1] != expected.positiveRange || |
| precision != expected.precision) |
| { |
| m_log << tcu::TestLog::Message << "// ERROR: Invalid precision format, expected:\n" |
| << "\trange[0] = " << expected.negativeRange << "\n" |
| << "\trange[1] = " << expected.positiveRange << "\n" |
| << "\tprecision = " << expected.precision << tcu::TestLog::EndMessage; |
| error = true; |
| } |
| } |
| else |
| { |
| if (range[0] < expected.negativeRange) |
| { |
| m_log << tcu::TestLog::Message << "// ERROR: Invalid range[0], expected greater or equal to " |
| << expected.negativeRange << tcu::TestLog::EndMessage; |
| error = true; |
| } |
| |
| if (range[1] < expected.positiveRange) |
| { |
| m_log << tcu::TestLog::Message << "// ERROR: Invalid range[1], expected greater or equal to " |
| << expected.positiveRange << tcu::TestLog::EndMessage; |
| error = true; |
| } |
| |
| if (precision < expected.precision) |
| { |
| m_log << tcu::TestLog::Message << "// ERROR: Invalid precision, expected greater or equal to " |
| << expected.precision << tcu::TestLog::EndMessage; |
| error = true; |
| } |
| } |
| |
| if (error) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid precision/range"); |
| } |
| |
| RequiredFormat getRequiredFormat(void) const |
| { |
| // Precisions for different types. |
| const RequiredFormat requirements[] = { |
| {0, 0, 8}, //!< lowp float |
| {13, 13, 10}, //!< mediump float |
| {127, 127, 23}, //!< highp float |
| {8, 7, 0}, //!< lowp int |
| {15, 14, 0}, //!< mediump int |
| {31, 30, 0}, //!< highp int |
| }; |
| const int ndx = (int)m_precisionType - (int)GL_LOW_FLOAT; |
| |
| DE_ASSERT(ndx >= 0); |
| DE_ASSERT(ndx < DE_LENGTH_OF_ARRAY(requirements)); |
| return requirements[ndx]; |
| } |
| |
| const glw::GLenum m_shaderType; |
| const glw::GLenum m_precisionType; |
| }; |
| |
| } // namespace |
| |
| ShaderStateQueryTests::ShaderStateQueryTests(Context &context) |
| : TestCaseGroup(context, "shader", "Shader State Query tests") |
| { |
| } |
| |
| void ShaderStateQueryTests::init(void) |
| { |
| // shader |
| addChild(new ShaderTypeCase(m_context, "shader_type", "SHADER_TYPE")); |
| addChild(new ShaderCompileStatusCase(m_context, "shader_compile_status", "COMPILE_STATUS")); |
| addChild(new ShaderInfoLogCase(m_context, "shader_info_log_length", "INFO_LOG_LENGTH")); |
| addChild(new ShaderSourceCase(m_context, "shader_source_length", "SHADER_SOURCE_LENGTH")); |
| |
| // shader and program |
| addChild(new DeleteStatusCase(m_context, "delete_status", "DELETE_STATUS")); |
| |
| // vertex-attrib |
| addChild(new CurrentVertexAttribInitialCase(m_context, "current_vertex_attrib_initial", "CURRENT_VERTEX_ATTRIB")); |
| addChild(new CurrentVertexAttribFloatCase(m_context, "current_vertex_attrib_float", "CURRENT_VERTEX_ATTRIB")); |
| addChild(new CurrentVertexAttribIntCase(m_context, "current_vertex_attrib_int", "CURRENT_VERTEX_ATTRIB")); |
| addChild(new CurrentVertexAttribUintCase(m_context, "current_vertex_attrib_uint", "CURRENT_VERTEX_ATTRIB")); |
| addChild(new CurrentVertexAttribConversionCase(m_context, "current_vertex_attrib_float_to_int", |
| "CURRENT_VERTEX_ATTRIB")); |
| |
| // program |
| addChild(new ProgramInfoLogCase(m_context, "program_info_log_length", "INFO_LOG_LENGTH", |
| ProgramInfoLogCase::BUILDERROR_COMPILE)); |
| addChild(new ProgramInfoLogCase(m_context, "program_info_log_length_link_error", "INFO_LOG_LENGTH", |
| ProgramInfoLogCase::BUILDERROR_LINK)); |
| addChild(new ProgramValidateStatusCase(m_context, "program_validate_status", "VALIDATE_STATUS")); |
| addChild(new ProgramAttachedShadersCase(m_context, "program_attached_shaders", "ATTACHED_SHADERS")); |
| |
| addChild(new ProgramActiveUniformNameCase(m_context, "program_active_uniform_name", |
| "ACTIVE_UNIFORMS and ACTIVE_UNIFORM_MAX_LENGTH")); |
| addChild(new ProgramUniformCase(m_context, "program_active_uniform_types", |
| "UNIFORM_TYPE, UNIFORM_SIZE, and UNIFORM_IS_ROW_MAJOR")); |
| addChild(new ProgramActiveUniformBlocksCase(m_context, "program_active_uniform_blocks", "ACTIVE_UNIFORM_BLOCK_x")); |
| addChild(new ProgramBinaryCase(m_context, "program_binary", |
| "PROGRAM_BINARY_LENGTH and PROGRAM_BINARY_RETRIEVABLE_HINT")); |
| |
| // transform feedback |
| addChild(new TransformFeedbackCase( |
| m_context, "transform_feedback", |
| "TRANSFORM_FEEDBACK_BUFFER_MODE, TRANSFORM_FEEDBACK_VARYINGS, TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH")); |
| |
| // attribute related |
| addChild( |
| new ActiveAttributesCase(m_context, "active_attributes", "ACTIVE_ATTRIBUTES and ACTIVE_ATTRIBUTE_MAX_LENGTH")); |
| addChild(new VertexAttributeSizeCase(m_context, "vertex_attrib_size", "VERTEX_ATTRIB_ARRAY_SIZE")); |
| addChild(new VertexAttributeTypeCase(m_context, "vertex_attrib_type", "VERTEX_ATTRIB_ARRAY_TYPE")); |
| addChild(new VertexAttributeStrideCase(m_context, "vertex_attrib_stride", "VERTEX_ATTRIB_ARRAY_STRIDE")); |
| addChild( |
| new VertexAttributeNormalizedCase(m_context, "vertex_attrib_normalized", "VERTEX_ATTRIB_ARRAY_NORMALIZED")); |
| addChild(new VertexAttributeIntegerCase(m_context, "vertex_attrib_integer", "VERTEX_ATTRIB_ARRAY_INTEGER")); |
| addChild(new VertexAttributeEnabledCase(m_context, "vertex_attrib_array_enabled", "VERTEX_ATTRIB_ARRAY_ENABLED")); |
| addChild(new VertexAttributeDivisorCase(m_context, "vertex_attrib_array_divisor", "VERTEX_ATTRIB_ARRAY_DIVISOR")); |
| addChild(new VertexAttributeBufferBindingCase(m_context, "vertex_attrib_array_buffer_binding", |
| "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING")); |
| addChild(new VertexAttributePointerCase(m_context, "vertex_attrib_pointerv", "GetVertexAttribPointerv")); |
| |
| // uniform values |
| addChild(new UniformValueFloatCase(m_context, "uniform_value_float", "GetUniform*")); |
| addChild(new UniformValueIntCase(m_context, "uniform_value_int", "GetUniform*")); |
| addChild(new UniformValueUintCase(m_context, "uniform_value_uint", "GetUniform*")); |
| addChild(new UniformValueBooleanCase(m_context, "uniform_value_boolean", "GetUniform*")); |
| addChild(new UniformValueSamplerCase(m_context, "uniform_value_sampler", "GetUniform*")); |
| addChild(new UniformValueArrayCase(m_context, "uniform_value_array", "GetUniform*")); |
| addChild(new UniformValueMatrixCase(m_context, "uniform_value_matrix", "GetUniform*")); |
| |
| // precision format query |
| addChild(new PrecisionFormatCase(m_context, "precision_vertex_lowp_float", "GetShaderPrecisionFormat", |
| GL_VERTEX_SHADER, GL_LOW_FLOAT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_vertex_mediump_float", "GetShaderPrecisionFormat", |
| GL_VERTEX_SHADER, GL_MEDIUM_FLOAT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_vertex_highp_float", "GetShaderPrecisionFormat", |
| GL_VERTEX_SHADER, GL_HIGH_FLOAT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_vertex_lowp_int", "GetShaderPrecisionFormat", |
| GL_VERTEX_SHADER, GL_LOW_INT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_vertex_mediump_int", "GetShaderPrecisionFormat", |
| GL_VERTEX_SHADER, GL_MEDIUM_INT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_vertex_highp_int", "GetShaderPrecisionFormat", |
| GL_VERTEX_SHADER, GL_HIGH_INT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_fragment_lowp_float", "GetShaderPrecisionFormat", |
| GL_FRAGMENT_SHADER, GL_LOW_FLOAT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_fragment_mediump_float", "GetShaderPrecisionFormat", |
| GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_fragment_highp_float", "GetShaderPrecisionFormat", |
| GL_FRAGMENT_SHADER, GL_HIGH_FLOAT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_fragment_lowp_int", "GetShaderPrecisionFormat", |
| GL_FRAGMENT_SHADER, GL_LOW_INT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_fragment_mediump_int", "GetShaderPrecisionFormat", |
| GL_FRAGMENT_SHADER, GL_MEDIUM_INT)); |
| addChild(new PrecisionFormatCase(m_context, "precision_fragment_highp_int", "GetShaderPrecisionFormat", |
| GL_FRAGMENT_SHADER, GL_HIGH_INT)); |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
