| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2014-2016 The Khronos Group Inc. |
| * |
| * 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 |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "esextcTessellationShaderErrors.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| #include <cstdarg> |
| #include <cstdio> |
| #include <cstring> |
| |
| namespace glcts |
| { |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| TessellationShaderErrors::TessellationShaderErrors(Context& context, const ExtParameters& extParams) |
| : TestCaseGroupBase(context, extParams, "compilation_and_linking_errors", |
| "Checks that the implementation correctly responds to" |
| "various errors in shaders which should result in compilation" |
| "or linking errors") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /* Instantiates all tests and adds them as children to the node */ |
| void TessellationShaderErrors::init(void) |
| { |
| addChild(new glcts::TessellationShaderError1InputBlocks(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError1InputVariables(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError2OutputBlocks(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError2OutputVariables(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError3InputBlocks(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError3InputVariables(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError4InputBlocks(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError4InputVariables(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError5InputBlocks(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError5InputVariables(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError6(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError7(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError8(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError9(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError10(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError11(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError12(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderError13(m_context, m_extParams)); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| TessellationShaderErrorsTestCaseBase::TessellationShaderErrorsTestCaseBase(Context& context, |
| const ExtParameters& extParams, |
| const char* name, const char* description) |
| : TestCaseBase(context, extParams, name, description) |
| , m_fs_ids(DE_NULL) |
| , m_n_program_objects(0) |
| , m_po_ids(DE_NULL) |
| , m_tc_ids(DE_NULL) |
| , m_te_ids(DE_NULL) |
| , m_vs_ids(DE_NULL) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all ES objects that were created for the test */ |
| void TessellationShaderErrorsTestCaseBase::deinit() |
| { |
| /* Call base class' deinit() */ |
| TestCaseBase::deinit(); |
| |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Release all shader objects created for the test */ |
| for (unsigned int n_program_object = 0; n_program_object < m_n_program_objects; ++n_program_object) |
| { |
| if (m_fs_ids != DE_NULL && m_fs_ids[n_program_object] != 0) |
| { |
| gl.deleteShader(m_fs_ids[n_program_object]); |
| |
| m_fs_ids[n_program_object] = 0; |
| } |
| |
| if (m_po_ids != DE_NULL && m_po_ids[n_program_object] != 0) |
| { |
| gl.deleteProgram(m_po_ids[n_program_object]); |
| |
| m_po_ids[n_program_object] = 0; |
| } |
| |
| if (m_tc_ids != DE_NULL && m_tc_ids[n_program_object] != 0) |
| { |
| gl.deleteShader(m_tc_ids[n_program_object]); |
| |
| m_tc_ids[n_program_object] = 0; |
| } |
| |
| if (m_te_ids != DE_NULL && m_te_ids[n_program_object] != 0) |
| { |
| gl.deleteShader(m_te_ids[n_program_object]); |
| |
| m_te_ids[n_program_object] = 0; |
| } |
| |
| if (m_vs_ids != DE_NULL && m_vs_ids[n_program_object] != 0) |
| { |
| gl.deleteShader(m_vs_ids[n_program_object]); |
| |
| m_vs_ids[n_program_object] = 0; |
| } |
| } /* for (all shader objects) */ |
| |
| /* Release buffers allocated for the test */ |
| if (m_fs_ids != DE_NULL) |
| { |
| delete[] m_fs_ids; |
| |
| m_fs_ids = DE_NULL; |
| } |
| |
| if (m_po_ids != DE_NULL) |
| { |
| delete[] m_po_ids; |
| |
| m_po_ids = DE_NULL; |
| } |
| |
| if (m_tc_ids != DE_NULL) |
| { |
| delete[] m_tc_ids; |
| |
| m_tc_ids = DE_NULL; |
| } |
| |
| if (m_te_ids != DE_NULL) |
| { |
| delete[] m_te_ids; |
| |
| m_te_ids = DE_NULL; |
| } |
| |
| if (m_vs_ids != DE_NULL) |
| { |
| delete[] m_vs_ids; |
| |
| m_vs_ids = DE_NULL; |
| } |
| } |
| |
| /** Executes the test. |
| * |
| * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. |
| * |
| * Note the function throws exception should an error occur! |
| * |
| * @return STOP if the test has finished, CONTINUE to indicate iterate() should be called once again. |
| **/ |
| tcu::TestNode::IterateResult TessellationShaderErrorsTestCaseBase::iterate() |
| { |
| /* Do not execute if required extensions are not supported. */ |
| if (!m_is_tessellation_shader_supported) |
| { |
| throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED); |
| } |
| |
| /* Retrieve ES entry-points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create as many program objects as will be needed */ |
| m_n_program_objects = getAmountOfProgramObjects(); |
| m_po_ids = new glw::GLuint[m_n_program_objects]; |
| |
| memset(m_po_ids, 0, sizeof(glw::GLuint) * m_n_program_objects); |
| |
| for (unsigned int n_po = 0; n_po < m_n_program_objects; ++n_po) |
| { |
| m_po_ids[n_po] = gl.createProgram(); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() failed"); |
| } |
| |
| /* Allocate space for shader IDs */ |
| bool is_fs_used = isPipelineStageUsed(PIPELINE_STAGE_FRAGMENT); |
| bool is_tc_used = isPipelineStageUsed(PIPELINE_STAGE_TESSELLATION_CONTROL); |
| bool is_te_used = isPipelineStageUsed(PIPELINE_STAGE_TESSELLATION_EVALUATION); |
| bool is_vs_used = isPipelineStageUsed(PIPELINE_STAGE_VERTEX); |
| |
| if (is_fs_used) |
| { |
| m_fs_ids = new glw::GLuint[m_n_program_objects]; |
| |
| memset(m_fs_ids, 0, sizeof(glw::GLuint) * m_n_program_objects); |
| } |
| |
| if (is_tc_used) |
| { |
| m_tc_ids = new glw::GLuint[m_n_program_objects]; |
| |
| memset(m_tc_ids, 0, sizeof(glw::GLuint) * m_n_program_objects); |
| } |
| |
| if (is_te_used) |
| { |
| m_te_ids = new glw::GLuint[m_n_program_objects]; |
| |
| memset(m_te_ids, 0, sizeof(glw::GLuint) * m_n_program_objects); |
| } |
| |
| if (is_vs_used) |
| { |
| m_vs_ids = new glw::GLuint[m_n_program_objects]; |
| |
| memset(m_vs_ids, 0, sizeof(glw::GLuint) * m_n_program_objects); |
| } |
| |
| /* Iterate through all program objects the test wants to check */ |
| for (unsigned int n_po = 0; n_po < m_n_program_objects; ++n_po) |
| { |
| _linking_result expected_linking_result = getLinkingResult(); |
| bool should_try_to_link = true; |
| |
| /* Iterate through all shader types */ |
| for (int stage = static_cast<int>(PIPELINE_STAGE_FIRST); stage < static_cast<int>(PIPELINE_STAGE_COUNT); |
| stage++) |
| { |
| if (!isPipelineStageUsed(static_cast<_pipeline_stage>(stage))) |
| { |
| continue; |
| } |
| |
| _compilation_result expected_compilation_result = getCompilationResult(static_cast<_pipeline_stage>(stage)); |
| std::string so_code; |
| glw::GLuint* so_id_ptr = DE_NULL; |
| std::string so_type; |
| |
| switch (static_cast<_pipeline_stage>(stage)) |
| { |
| case PIPELINE_STAGE_FRAGMENT: |
| { |
| so_code = getFragmentShaderCode(n_po); |
| so_id_ptr = m_fs_ids + n_po; |
| so_type = "fragment"; |
| |
| break; |
| } |
| |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| { |
| so_code = getTessellationControlShaderCode(n_po); |
| so_id_ptr = m_tc_ids + n_po; |
| so_type = "tessellation control"; |
| |
| break; |
| } |
| |
| case PIPELINE_STAGE_TESSELLATION_EVALUATION: |
| { |
| so_code = getTessellationEvaluationShaderCode(n_po); |
| so_id_ptr = m_te_ids + n_po; |
| so_type = "tessellation evaluation"; |
| |
| break; |
| } |
| |
| case PIPELINE_STAGE_VERTEX: |
| { |
| so_code = getVertexShaderCode(n_po); |
| so_id_ptr = m_vs_ids + n_po; |
| so_type = "vertex"; |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized pipeline stage"); |
| } |
| } /* switch (stage) */ |
| |
| /* Generate the shader object */ |
| *so_id_ptr = gl.createShader(getGLEnumForPipelineStage(static_cast<_pipeline_stage>(stage))); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() failed"); |
| |
| /* Assign source code to the object */ |
| const char* so_unspecialized_code_ptr = so_code.c_str(); |
| std::string so_specialized_code = specializeShader(1, &so_unspecialized_code_ptr); |
| const char* so_code_ptr = so_specialized_code.c_str(); |
| |
| gl.shaderSource(*so_id_ptr, 1 /* count */, &so_code_ptr, NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed"); |
| |
| /* Try to compile the shader object */ |
| glw::GLint compile_status = GL_FALSE; |
| |
| gl.compileShader(*so_id_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed"); |
| |
| /* Retrieve the compile status and make sure it matches the desired outcome */ |
| gl.getShaderiv(*so_id_ptr, GL_COMPILE_STATUS, &compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed"); |
| |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << so_type << " shader source:\n" |
| << so_code_ptr << tcu::TestLog::EndMessage; |
| |
| glw::GLint length = 0; |
| gl.getShaderiv(*so_id_ptr, GL_INFO_LOG_LENGTH, &length); |
| if (length > 1) |
| { |
| std::vector<glw::GLchar> log(length); |
| gl.getShaderInfoLog(*so_id_ptr, length, NULL, &log[0]); |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "shader info log\n" |
| << &log[0] << tcu::TestLog::EndMessage; |
| } |
| |
| switch (expected_compilation_result) |
| { |
| case COMPILATION_RESULT_CAN_FAIL: |
| { |
| if (compile_status == GL_FALSE) |
| { |
| /* OK, this is valid. However, it no longer makes sense to try to |
| * link the program object at this point. */ |
| should_try_to_link = false; |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Compilation failed as allowed." << tcu::TestLog::EndMessage; |
| } |
| else |
| { |
| /* That's fine. */ |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Compilation passed as allowed." << tcu::TestLog::EndMessage; |
| } |
| |
| break; |
| } |
| |
| case COMPILATION_RESULT_MUST_FAIL: |
| { |
| if (compile_status == GL_TRUE) |
| { |
| /* Test has failed */ |
| TCU_FAIL("A shader compiled successfully, even though it should have failed " |
| "to do so"); |
| } |
| else |
| { |
| /* OK. Mark the program object as non-linkable */ |
| should_try_to_link = false; |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Compilation failed as expected." << tcu::TestLog::EndMessage; |
| } |
| |
| break; |
| } |
| |
| case COMPILATION_RESULT_MUST_SUCCEED: |
| { |
| if (compile_status != GL_TRUE) |
| { |
| /* Test has failed */ |
| TCU_FAIL("A shader failed to compile, even though it should have succeeded " |
| "to do so"); |
| } |
| else |
| { |
| /* That's fine. */ |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Compilation successful as expected." << tcu::TestLog::EndMessage; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized expected compilation result"); |
| } |
| } /* switch (expected_compilation_result) */ |
| |
| /* If it still makes sense to do so, attach the shader object to |
| * the test program object */ |
| if (should_try_to_link) |
| { |
| gl.attachShader(m_po_ids[n_po], *so_id_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed"); |
| } |
| } /* for (all pipeline stages) */ |
| |
| /* If it still makes sense, try to link the program object */ |
| if (should_try_to_link) |
| { |
| gl.linkProgram(m_po_ids[n_po]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed"); |
| |
| /* Retrieve the link status and compare it against the expected linking result */ |
| glw::GLint link_status = GL_FALSE; |
| |
| gl.getProgramiv(m_po_ids[n_po], GL_LINK_STATUS, &link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed"); |
| |
| glw::GLint length = 0; |
| gl.getProgramiv(m_po_ids[n_po], GL_INFO_LOG_LENGTH, &length); |
| if (length > 1) |
| { |
| std::vector<glw::GLchar> log(length); |
| gl.getProgramInfoLog(m_po_ids[n_po], length, NULL, &log[0]); |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "program info log\n" |
| << &log[0] << tcu::TestLog::EndMessage; |
| } |
| |
| switch (expected_linking_result) |
| { |
| case LINKING_RESULT_MUST_FAIL: |
| { |
| if (link_status != GL_FALSE) |
| { |
| TCU_FAIL("Program object was expected not to link but linking operation succeeded."); |
| } |
| else |
| { |
| /* That's OK */ |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Linking failed as expected." << tcu::TestLog::EndMessage; |
| } |
| |
| break; |
| } |
| |
| case LINKING_RESULT_MUST_SUCCEED: |
| { |
| if (link_status != GL_TRUE) |
| { |
| TCU_FAIL("Program object was expected to link successfully but linking operation failed."); |
| } |
| else |
| { |
| /* That's OK */ |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Linking succeeded as expected." << tcu::TestLog::EndMessage; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized expected linking result"); |
| } |
| } /* switch (expected_linking_result) */ |
| } /* if (should_try_to_link) */ |
| } /* for (all program objects) */ |
| |
| /* If this point was reached, the test executed successfully */ |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| |
| return STOP; |
| } |
| |
| /** Retrieves amount of program objects the test that should be linked for |
| * the prupose of the test. |
| * |
| * @return As per description. |
| */ |
| unsigned int TessellationShaderErrorsTestCaseBase::getAmountOfProgramObjects() |
| { |
| return 1; |
| } |
| |
| /** Retrieves source code of fragment shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Fragment shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderErrorsTestCaseBase::getFragmentShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| } |
| |
| /** Retrieves GLenum equivalent of a pipeline stage value. |
| * |
| * Throws TestError exception if @param stage is invalid. |
| * |
| * @param stage Pipeline stage to convert from |
| * |
| * @return GL_*_SHADER equivalent of the user-provided value. |
| **/ |
| glw::GLenum TessellationShaderErrorsTestCaseBase::getGLEnumForPipelineStage(_pipeline_stage stage) |
| { |
| glw::GLenum result = GL_NONE; |
| |
| switch (stage) |
| { |
| case PIPELINE_STAGE_FRAGMENT: |
| result = GL_FRAGMENT_SHADER; |
| break; |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| result = m_glExtTokens.TESS_CONTROL_SHADER; |
| break; |
| case PIPELINE_STAGE_TESSELLATION_EVALUATION: |
| result = m_glExtTokens.TESS_EVALUATION_SHADER; |
| break; |
| case PIPELINE_STAGE_VERTEX: |
| result = GL_VERTEX_SHADER; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized pipeline stage"); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves source code of vertex shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Vertex shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderErrorsTestCaseBase::getVertexShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError1InputBlocks::TessellationShaderError1InputBlocks(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_non_arrayed_per_vertex_input_blocks", |
| "Tries to use non-arrayed per-vertex input blocks" |
| "in a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError1InputBlocks::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully |
| * |
| * NOTE: Vertex shader compilation can fail if underlying implementation does not support |
| * GL_EXT_shader_io_blocks. |
| **/ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_VERTEX: |
| return COMPILATION_RESULT_CAN_FAIL; |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError1InputBlocks::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError1InputBlocks::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| /* Invalid input block declaration */ |
| "in IN_TC\n" |
| "{\n" |
| " vec4 test_block_field;\n" |
| "} test_block;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = test_block.test_block_field;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError1InputBlocks::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of vertex shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Vertex shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError1InputBlocks::getVertexShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${SHADER_IO_BLOCKS_REQUIRE}\n" |
| "\n" |
| "out IN_TC\n" |
| "{\n" |
| " vec4 test_block_field;\n" |
| "} test_block;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " test_block.test_block_field = vec4(1.0, 2.0, 3.0, gl_VertexID);\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError1InputBlocks::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError1InputVariables::TessellationShaderError1InputVariables(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_non_arrayed_per_vertex_input_variables", |
| "Tries to use non-arrayed per-vertex input variables" |
| "in a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError1InputVariables::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError1InputVariables::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError1InputVariables::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| /* Invalid input declaration */ |
| "in vec4 test_field;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = test_field;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError1InputVariables::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of vertex shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Vertex shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError1InputVariables::getVertexShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "out vec4 test_field;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " test_field = vec4(1.0, 2.0, 3.0, gl_VertexID);\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError1InputVariables::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError2OutputBlocks::TessellationShaderError2OutputBlocks(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_non_arrayed_per_vertex_output_blocks", |
| "Tries to use non-arrayed per-vertex output blocks" |
| "in a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError2OutputBlocks::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError2OutputBlocks::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError2OutputBlocks::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| /* Invalid output block declaration */ |
| "out OUT_TC\n" |
| "{\n" |
| " vec4 test_block_field;\n" |
| "} test_block;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = test_block.test_block_field;\n" |
| " test_block.test_block_field = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError2OutputBlocks::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError2OutputBlocks::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError2OutputVariables::TessellationShaderError2OutputVariables(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_non_arrayed_per_vertex_output_variabless", |
| "Tries to use non-arrayed per-vertex output variables" |
| "in a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError2OutputVariables::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError2OutputVariables::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError2OutputVariables::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| /* Invalid output declaration */ |
| "out vec4 test_field;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = vec4(2.0);\n" |
| " test_field = vec4(3.0);\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError2OutputVariables::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError2OutputVariables::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError3InputBlocks::TessellationShaderError3InputBlocks(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_non_arrayed_per_vertex_input_blocks", |
| "Tries to use non-arrayed per-vertex input blocks" |
| "in a tessellation evaluation shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError3InputBlocks::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation evaluation shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_EVALUATION: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError3InputBlocks::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError3InputBlocks::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "out IN_TE\n" |
| "{\n" |
| " vec4 test_block_field;\n" |
| "} test_block[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out [gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " test_block [gl_InvocationID].test_block_field = vec4(2.0);\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError3InputBlocks::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| /* Invalid input block declaration */ |
| "in IN_TE\n" |
| "{\n" |
| " vec4 test_block_field;\n" |
| "} test_block;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position * test_block.test_block_field;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError3InputBlocks::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError3InputVariables::TessellationShaderError3InputVariables(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_non_arrayed_per_vertex_input_variables", |
| "Tries to use non-arrayed per-vertex input variables " |
| "in a tessellation evaluation shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError3InputVariables::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation evaluation shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_EVALUATION: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError3InputVariables::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError3InputVariables::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "out vec4 test_field[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out [gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " test_field [gl_InvocationID] = vec4(4.0);\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError3InputVariables::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| /* Invalid input declaration */ |
| "in vec4 test_field;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position * test_field;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError3InputVariables::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError4InputBlocks::TessellationShaderError4InputBlocks(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_invalid_array_size_used_for_input_blocks", |
| "Tries to use invalid array size when defining input blocks " |
| "in a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError4InputBlocks::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError4InputBlocks::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError4InputBlocks::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| /* Invalid input block size */ |
| "in IN_TC\n" |
| "{\n" |
| " vec4 input_block_input;\n" |
| "} input_block[11];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = input_block[gl_InvocationID].input_block_input;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError4InputBlocks::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError4InputBlocks::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError4InputVariables::TessellationShaderError4InputVariables(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_invalid_array_size_used_for_input_variables", |
| "Tries to use invalid array size when defining input variables" |
| " in a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError4InputVariables::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError4InputVariables::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError4InputVariables::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| /* Invalid array size */ |
| "in vec4 test_input[11];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = test_input[gl_InvocationID];\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError4InputVariables::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError4InputVariables::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError5InputBlocks::TessellationShaderError5InputBlocks(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_invalid_array_size_used_for_input_blocks", |
| "Tries to use invalid array size when defining input " |
| "blocks in a tessellation evaluation shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError5InputBlocks::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation evaluation shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_EVALUATION: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError5InputBlocks::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError5InputBlocks::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError5InputBlocks::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| /* Invalid input block size */ |
| "in IN_TC\n" |
| "{\n" |
| " vec4 input_block_input;\n" |
| "} input_block[11];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position * input_block[0].input_block_input;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError5InputBlocks::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError5InputVariables::TessellationShaderError5InputVariables(Context& context, |
| const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_invalid_array_size_used_for_input_variables", |
| "Tries to use invalid array size when defining input " |
| "variables in a tessellation evaluation shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError5InputVariables::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation evaluation shader is allowed to fail to compile, |
| * shaders for all other stages should compile successfully */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_EVALUATION: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError5InputVariables::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError5InputVariables::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError5InputVariables::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| /* Invalid array size */ |
| "in vec4 test_input[11];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position * test_input[0];\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError5InputVariables::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError6::TessellationShaderError6(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_invalid_output_patch_vertex_count", |
| "Tries to use invalid output patch vertex count in" |
| " a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Retrieves amount of program objects the test that should be linked for |
| * the prupose of the test. |
| * |
| * @return As per description. |
| */ |
| unsigned int TessellationShaderError6::getAmountOfProgramObjects() |
| { |
| return 2; |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError6::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* Tessellation control shader is allowed to fail to compile */ |
| switch (pipeline_stage) |
| { |
| case PIPELINE_STAGE_TESSELLATION_CONTROL: |
| return COMPILATION_RESULT_CAN_FAIL; |
| default: |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError6::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError6::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| std::stringstream result; |
| const char* tc_code_preamble = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n"; |
| const char* tc_code_body_excl_layout_qualifiers = "\n" |
| "in vec4 test_input[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = test_input[0];\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| |
| /* Prepare the line with layout qualifier */ |
| std::stringstream tc_code_layout_qualifier_sstream; |
| std::string tc_code_layout_qualifier_string; |
| |
| if (n_program_object == 0) |
| { |
| tc_code_layout_qualifier_string = "layout (vertices = 0) out;\n"; |
| } |
| else |
| { |
| /* Retrieve GL_MAX_PATCH_VERTICES_EXT value first */ |
| glw::GLint gl_max_patch_vertices_value = 0; |
| |
| gl.getIntegerv(m_glExtTokens.MAX_PATCH_VERTICES, &gl_max_patch_vertices_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_PATCH_VERTICES_EXT pname"); |
| |
| /* Construct the string */ |
| tc_code_layout_qualifier_sstream << "layout (vertices = " << (gl_max_patch_vertices_value + 1) << ") out;\n"; |
| |
| tc_code_layout_qualifier_string = tc_code_layout_qualifier_sstream.str(); |
| } |
| |
| result << tc_code_preamble << tc_code_layout_qualifier_string << tc_code_body_excl_layout_qualifiers; |
| |
| return result.str(); |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError6::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError6::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError7::TessellationShaderError7(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, |
| "tc_invalid_write_operation_at_non_gl_invocation_id_index", |
| "Tries to write to a per-vertex output variable at index" |
| " which is not equal to gl_InvocationID") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError7::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* TC stage should _may_ fail to compile (but linking *must* fail) */ |
| return (pipeline_stage == PIPELINE_STAGE_TESSELLATION_CONTROL) ? COMPILATION_RESULT_CAN_FAIL : |
| COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError7::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError7::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "out vec4 test[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[2].gl_Position = gl_in[0].gl_Position;\n" |
| " test[2] = gl_in[1].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError7::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError7::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| /* All stages used */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError8::TessellationShaderError8(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_invalid_input_per_patch_attribute_definition", |
| "Tries to define input per-patch attributes in " |
| "a tessellation control shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError8::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* TC stage should never compile, all stages are out of scope */ |
| return (pipeline_stage == PIPELINE_STAGE_TESSELLATION_CONTROL) ? COMPILATION_RESULT_MUST_FAIL : |
| COMPILATION_RESULT_UNKNOWN; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError8::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError8::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "patch in vec4 test;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = test;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError8::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| /* This function should never be called */ |
| DE_ASSERT(false); |
| |
| return ""; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError8::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| /* Only TC stage is used */ |
| return (stage == PIPELINE_STAGE_TESSELLATION_CONTROL); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError9::TessellationShaderError9(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_invalid_output_per_patch_attribute_definition", |
| "Tries to define output per-patch attributes in " |
| "a tessellation evaluation shader") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError9::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* TE stage should never compile, all stages are out of scope */ |
| return (pipeline_stage == PIPELINE_STAGE_TESSELLATION_EVALUATION) ? COMPILATION_RESULT_MUST_FAIL : |
| COMPILATION_RESULT_UNKNOWN; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError9::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError9::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| /* This function should never be called */ |
| DE_ASSERT(false); |
| |
| return ""; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError9::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (isolines) in;\n" |
| "\n" |
| "patch out vec4 test;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(1.0, 0.0, 0.0, 0.0);\n" |
| " test = vec4(0.0, 1.0, 0.0, 0.0);\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError9::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| /* Only TE stage is used */ |
| return (stage == PIPELINE_STAGE_TESSELLATION_EVALUATION); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError10::TessellationShaderError10(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "tc_non_matching_variable_declarations", |
| "Tries to define variables of different types/qualifications" |
| " in tessellation control and tessellation evaluation shaders") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError10::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| DE_UNREF(pipeline_stage); |
| /* All stages should compile */ |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError10::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError10::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "patch out float test;\n" |
| "patch out vec4 test2;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " test = 1.0;\n" |
| " test2 = vec4(0.1, 0.2, 0.3, 0.4);\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError10::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| "patch in uint test;\n" |
| "patch in float test2;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position * float(int(test)) * vec4(test2);\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError10::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError11::TessellationShaderError11(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_lacking_primitive_mode_declaration", |
| "Tries to link a tessellation evaluation shader" |
| " without a primitive mode declaration") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError11::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| DE_UNREF(pipeline_stage); |
| |
| /* All stages should compile */ |
| return COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError11::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError11::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError11::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError11::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError12::TessellationShaderError12(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_accessing_glTessCoord_as_array", |
| "Tries to access gl_TessCoord as if it was an array") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError12::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* It is OK for TE stage to fail to compile. Other stages must compile successfully */ |
| /* All stages should compile */ |
| return (pipeline_stage == PIPELINE_STAGE_TESSELLATION_EVALUATION) ? COMPILATION_RESULT_CAN_FAIL : |
| COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError12::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError12::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError12::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| "out vec3 test;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " test = gl_TessCoord[0].xyz;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError12::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderError13::TessellationShaderError13(Context& context, const ExtParameters& extParams) |
| : TessellationShaderErrorsTestCaseBase(context, extParams, "te_accessing_glTessCoord_as_gl_in_member", |
| "Tries to access gl_TessCoord as if it was a gl_in[] member") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Determines what compilation result is anticipated for each of the pipeline stages. |
| * |
| * @param pipeline_stage Pipeline stage to return compilation result for. |
| * |
| * @return Requested compilation result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_compilation_result TessellationShaderError13::getCompilationResult( |
| _pipeline_stage pipeline_stage) |
| { |
| /* It is OK for TE stage to fail to compile. Other stages must compile successfully */ |
| /* All stages should compile */ |
| return (pipeline_stage == PIPELINE_STAGE_TESSELLATION_EVALUATION) ? COMPILATION_RESULT_CAN_FAIL : |
| COMPILATION_RESULT_MUST_SUCCEED; |
| } |
| |
| /** Determines what linking result is anticipated for all program objects created by the test. |
| * |
| * @return Expected linking result. |
| **/ |
| TessellationShaderErrorsTestCaseBase::_linking_result TessellationShaderError13::getLinkingResult() |
| { |
| return LINKING_RESULT_MUST_FAIL; |
| } |
| |
| /** Retrieves source code of tessellation control shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation control shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError13::getTessellationControlShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices=4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves source code of tessellation evaluation shader that should be attached to the test |
| * program object. |
| * |
| * @param n_program_object Index of the program object the source code should |
| * be returned for. |
| * |
| * @return Tessellation evaluation shader source code to be used for user-specified program object. |
| */ |
| std::string TessellationShaderError13::getTessellationEvaluationShaderCode(unsigned int n_program_object) |
| { |
| DE_UNREF(n_program_object); |
| |
| return "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines) in;\n" |
| "\n" |
| "out vec3 test;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " test = gl_in[0].gl_TessCoord;\n" |
| "}\n"; |
| } |
| |
| /** Tells whether given pipeline stage should be used for the purpose of the test |
| * (for all program objects). |
| * |
| * @param Stage to query. |
| * |
| * @return True if a shader object implementing the stage should be attached to |
| * test program object; |
| * False otherwise. |
| **/ |
| bool TessellationShaderError13::isPipelineStageUsed(_pipeline_stage stage) |
| { |
| DE_UNREF(stage); |
| |
| return true; |
| } |
| |
| } /* namespace glcts */ |