| /*------------------------------------------------------------------------- |
| * 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 "esextcTessellationShaderProperties.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| #include <cmath> |
| #include <cstring> |
| |
| namespace glcts |
| { |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderPropertiesDefaultContextWideValues::TessellationShaderPropertiesDefaultContextWideValues( |
| Context &context, const ExtParameters &extParams) |
| : TestCaseBase(context, extParams, "default_values_of_context_wide_properties", |
| "Verifies default values of context-wide tessellation stage properties") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** 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 TessellationShaderPropertiesDefaultContextWideValues::iterate(void) |
| { |
| /* Do not execute if required extensions are not supported. */ |
| if (!m_is_tessellation_shader_supported) |
| { |
| throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED); |
| } |
| |
| /* Iterate through all context-wide properties and compare expected values |
| * against the reference ones |
| */ |
| const float epsilon = (float)1e-5; |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| const glw::GLint property_value_data[] = {/* pname */ /* n components */ /* default value */ |
| static_cast<glw::GLint>(m_glExtTokens.PATCH_VERTICES), 1, 3, |
| /* The following values are only applicable to Desktop OpenGL. */ |
| GL_PATCH_DEFAULT_OUTER_LEVEL, 4, 1, GL_PATCH_DEFAULT_INNER_LEVEL, 2, 1}; |
| |
| const unsigned int n_properties = (glu::isContextTypeES(m_context.getRenderContext().getType())) ? 1 : 3; |
| |
| for (unsigned int n_property = 0; n_property < n_properties; ++n_property) |
| { |
| glw::GLboolean bool_value[4] = {GL_FALSE}; |
| glw::GLfloat float_value[4] = {0.0f}; |
| glw::GLint int_value[4] = {0}; |
| |
| glw::GLenum pname = property_value_data[n_property * 3 + 0]; |
| glw::GLint n_components = property_value_data[n_property * 3 + 1]; |
| glw::GLint expected_value = property_value_data[n_property * 3 + 2]; |
| |
| /* Call all relevant getters */ |
| gl.getBooleanv(pname, bool_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() failed."); |
| |
| gl.getFloatv(pname, float_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() failed."); |
| |
| gl.getIntegerv(pname, int_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed."); |
| |
| /* Compare retrieved vector value components against expected value */ |
| glw::GLboolean expected_bool_value[4] = { |
| (expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE, |
| (expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE, |
| (expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE, |
| (expected_value != 0) ? (glw::GLboolean)GL_TRUE : (glw::GLboolean)GL_FALSE}; |
| glw::GLint expected_int_value[4] = {expected_value, expected_value, expected_value, expected_value}; |
| |
| if (memcmp(expected_bool_value, bool_value, sizeof(bool) * n_components) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glGetBooleanv() called for pname " << pname |
| << " reported invalid value." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported by glGetBooleanv()"); |
| } |
| |
| if (memcmp(expected_int_value, int_value, sizeof(int) * n_components) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glGetIntegerv() called for pname " << pname |
| << " reported invalid value." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported by glGetIntegerv()"); |
| } |
| |
| if ((n_components >= 1 && de::abs(float_value[0] - (float)expected_value) > epsilon) || |
| (n_components >= 2 && de::abs(float_value[1] - (float)expected_value) > epsilon) || |
| (n_components >= 3 && de::abs(float_value[2] - (float)expected_value) > epsilon) || |
| (n_components >= 4 && de::abs(float_value[3] - (float)expected_value) > epsilon)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glGetFloatv() called for pname " << pname |
| << " reported invalid value." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported by glGetFloatv()"); |
| } |
| } /* for (all properties) */ |
| |
| /* All done */ |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderPropertiesProgramObject::TessellationShaderPropertiesProgramObject(Context &context, |
| const ExtParameters &extParams) |
| : TestCaseBase(context, extParams, "program_object_properties", |
| "Verifies tessellation-specific properties of program objects are reported correctly.") |
| , m_fs_id(0) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Deinitializes ES objects created for the test */ |
| void TessellationShaderPropertiesProgramObject::deinit(void) |
| { |
| /* Call base class' deinit() */ |
| TestCaseBase::deinit(); |
| |
| /* Release any ES objects created */ |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Initializes ES objects necessary to execute the test */ |
| void TessellationShaderPropertiesProgramObject::initTest(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute if required extension is not supported */ |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| /* Generate all objects */ |
| m_po_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() failed"); |
| |
| m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); |
| m_tc_id = gl.createShader(m_glExtTokens.TESS_CONTROL_SHADER); |
| m_te_id = gl.createShader(m_glExtTokens.TESS_EVALUATION_SHADER); |
| m_vs_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() failed"); |
| |
| /* Attach the shader to the program object */ |
| gl.attachShader(m_po_id, m_fs_id); |
| gl.attachShader(m_po_id, m_tc_id); |
| gl.attachShader(m_po_id, m_te_id); |
| gl.attachShader(m_po_id, m_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed"); |
| |
| /* Since this test does not care much about fragment & vertex shaders, set |
| * their bodies and compile these shaders now */ |
| const char *fs_body = "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| const char *vs_body = "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| glw::GLint fs_compile_status = GL_FALSE; |
| glw::GLint vs_compile_status = GL_FALSE; |
| |
| shaderSourceSpecialized(m_fs_id, 1 /* count */, &fs_body); |
| shaderSourceSpecialized(m_vs_id, 1 /* count */, &vs_body); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed"); |
| |
| gl.compileShader(m_fs_id); |
| gl.compileShader(m_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed"); |
| |
| gl.getShaderiv(m_fs_id, GL_COMPILE_STATUS, &fs_compile_status); |
| gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &vs_compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed"); |
| |
| if (fs_compile_status != GL_TRUE) |
| { |
| TCU_FAIL("Could not compile fragment shader"); |
| } |
| |
| if (vs_compile_status != GL_TRUE) |
| { |
| TCU_FAIL("Could not compile vertex shader"); |
| } |
| } |
| |
| /** 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 TessellationShaderPropertiesProgramObject::iterate(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute if required extensions are not supported. */ |
| if (!m_is_tessellation_shader_supported) |
| { |
| throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED); |
| } |
| |
| /* Initialize ES test objects */ |
| initTest(); |
| |
| /* Test 1: Default values. Values as per spec, define as little qualifiers as possible */ |
| _test_descriptor test_1; |
| |
| test_1.expected_control_output_vertices_value = 4; |
| test_1.expected_gen_mode_value = m_glExtTokens.QUADS; |
| test_1.expected_gen_point_mode_value = GL_FALSE; |
| test_1.expected_gen_spacing_value = GL_EQUAL; |
| test_1.expected_gen_vertex_order_value = GL_CCW; |
| test_1.tc_body = "${VERSION}\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" |
| "}\n"; |
| test_1.te_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(quads) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| |
| /* Test 2: 16 vertices per patch + isolines + fractional_even_spacing + cw combination */ |
| _test_descriptor test_2; |
| |
| test_2.expected_control_output_vertices_value = 16; |
| test_2.expected_gen_mode_value = m_glExtTokens.ISOLINES; |
| test_2.expected_gen_point_mode_value = GL_FALSE; |
| test_2.expected_gen_spacing_value = m_glExtTokens.FRACTIONAL_EVEN; |
| test_2.expected_gen_vertex_order_value = GL_CW; |
| test_2.tc_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(vertices=16) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| "}\n"; |
| test_2.te_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines, fractional_even_spacing, cw) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| |
| /* Test 3: 32 vertices per patch + triangles + fractional_odd_spacing + ccw combination + point mode*/ |
| _test_descriptor test_3; |
| |
| test_3.expected_control_output_vertices_value = 32; |
| test_3.expected_gen_mode_value = GL_TRIANGLES; |
| test_3.expected_gen_point_mode_value = GL_TRUE; |
| test_3.expected_gen_spacing_value = m_glExtTokens.FRACTIONAL_ODD; |
| test_3.expected_gen_vertex_order_value = GL_CCW; |
| test_3.tc_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(vertices=32) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| "}\n"; |
| test_3.te_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(triangles, fractional_odd_spacing, ccw, point_mode) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| |
| /* Test 4: 8 vertices per patch + quads + equal_spacing + ccw combination + point mode*/ |
| _test_descriptor test_4; |
| |
| test_4.expected_control_output_vertices_value = 8; |
| test_4.expected_gen_mode_value = m_glExtTokens.QUADS; |
| test_4.expected_gen_point_mode_value = GL_TRUE; |
| test_4.expected_gen_spacing_value = GL_EQUAL; |
| test_4.expected_gen_vertex_order_value = GL_CCW; |
| test_4.tc_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(vertices=8) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n" |
| "}\n"; |
| test_4.te_body = "${VERSION}\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(quads, equal_spacing, ccw, point_mode) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| "}\n"; |
| |
| /* Store all tests in a single vector */ |
| _tests tests; |
| |
| tests.push_back(test_1); |
| tests.push_back(test_2); |
| tests.push_back(test_3); |
| tests.push_back(test_4); |
| |
| /* Iterate through all the tests and verify the values reported */ |
| for (_tests_const_iterator test_iterator = tests.begin(); test_iterator != tests.end(); test_iterator++) |
| { |
| const _test_descriptor &test = *test_iterator; |
| |
| /* Set tessellation control & evaluation shader bodies. */ |
| shaderSourceSpecialized(m_tc_id, 1 /* count */, &test.tc_body); |
| shaderSourceSpecialized(m_te_id, 1 /* count */, &test.te_body); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed"); |
| |
| /* Compile the shaders */ |
| gl.compileShader(m_tc_id); |
| gl.compileShader(m_te_id); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed"); |
| |
| /* Make sure the shaders compiled */ |
| glw::GLint tc_compile_status = GL_FALSE; |
| glw::GLint te_compile_status = GL_FALSE; |
| |
| gl.getShaderiv(m_tc_id, GL_COMPILE_STATUS, &tc_compile_status); |
| gl.getShaderiv(m_te_id, GL_COMPILE_STATUS, &te_compile_status); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed"); |
| |
| if (tc_compile_status != GL_TRUE) |
| { |
| TCU_FAIL("Could not compile tessellation control shader"); |
| } |
| |
| if (te_compile_status != GL_TRUE) |
| { |
| TCU_FAIL("Could not compile tessellation evaluation shader"); |
| } |
| |
| /* Try to link the program object */ |
| glw::GLint link_status = GL_FALSE; |
| |
| gl.linkProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed"); |
| |
| gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed"); |
| |
| if (link_status != GL_TRUE) |
| { |
| TCU_FAIL("Program linking failed"); |
| } |
| |
| /* Query the tessellation properties of the program object and make sure |
| * the values reported are valid */ |
| glw::GLint control_output_vertices_value = 0; |
| glw::GLint gen_mode_value = GL_NONE; |
| glw::GLint gen_spacing_value = GL_NONE; |
| glw::GLint gen_vertex_order_value = GL_NONE; |
| glw::GLint gen_point_mode_value = GL_NONE; |
| |
| gl.getProgramiv(m_po_id, m_glExtTokens.TESS_CONTROL_OUTPUT_VERTICES, &control_output_vertices_value); |
| gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_MODE, &gen_mode_value); |
| gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_SPACING, &gen_spacing_value); |
| gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_POINT_MODE, &gen_point_mode_value); |
| gl.getProgramiv(m_po_id, m_glExtTokens.TESS_GEN_VERTEX_ORDER, &gen_vertex_order_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() for tessellation-specific properties failed."); |
| |
| if (control_output_vertices_value != test.expected_control_output_vertices_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid value reported for GL_TESS_CONTROL_OUTPUT_VERTICES_EXT property; " |
| << " expected: " << test.expected_control_output_vertices_value |
| << ", retrieved: " << control_output_vertices_value << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported for GL_TESS_CONTROL_OUTPUT_VERTICES_EXT property."); |
| } |
| |
| if ((glw::GLuint)gen_mode_value != test.expected_gen_mode_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for GL_TESS_GEN_MODE_EXT property; " |
| << " expected: " << test.expected_gen_mode_value << ", retrieved: " << gen_mode_value |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported for GL_TESS_GEN_MODE_EXT property."); |
| } |
| |
| if ((glw::GLuint)gen_spacing_value != test.expected_gen_spacing_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid value reported for GL_TESS_GEN_SPACING_EXT property; " |
| << " expected: " << test.expected_gen_spacing_value |
| << ", retrieved: " << gen_spacing_value << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported for GL_TESS_GEN_SPACING_EXT property."); |
| } |
| |
| if ((glw::GLuint)gen_point_mode_value != test.expected_gen_point_mode_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid value reported for GL_TESS_GEN_POINT_MODE_EXT property; " |
| << " expected: " << test.expected_gen_point_mode_value |
| << ", retrieved: " << gen_point_mode_value << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported for GL_TESS_GEN_POINT_MODE_EXT property."); |
| } |
| |
| if ((glw::GLuint)gen_vertex_order_value != test.expected_gen_vertex_order_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid value reported for GL_TESS_GEN_VERTEX_ORDER_EXT property; " |
| << " expected: " << test.expected_gen_vertex_order_value |
| << ", retrieved: " << gen_vertex_order_value << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid value reported for GL_TESS_GEN_VERTEX_ORDER_EXT property."); |
| } |
| } /* for (all test descriptors) */ |
| |
| /* All done */ |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| } /* namespace glcts */ |
