| /*------------------------------------------------------------------------- |
| * 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 "esextcTessellationShaderPoints.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| namespace glcts |
| { |
| |
| const unsigned int TessellationShaderPointsgl_PointSize::m_rt_height = |
| 16; /* note: update shaders if you change this value */ |
| const unsigned int TessellationShaderPointsgl_PointSize::m_rt_width = |
| 16; /* note: update shaders if you change this value */ |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderPointsTests::TessellationShaderPointsTests(glcts::Context& context, const ExtParameters& extParams) |
| : TestCaseGroupBase(context, extParams, "tessellation_shader_point_mode", "Verifies point mode functionality") |
| { |
| /* No implementation needed */ |
| } |
| |
| /** |
| * Initializes test groups for geometry shader tests |
| **/ |
| void TessellationShaderPointsTests::init(void) |
| { |
| addChild(new glcts::TessellationShaderPointsgl_PointSize(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderPointsVerification(m_context, m_extParams)); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's desricption |
| **/ |
| TessellationShaderPointsgl_PointSize::TessellationShaderPointsgl_PointSize(Context& context, |
| const ExtParameters& extParams) |
| : TestCaseBase(context, extParams, "point_rendering", "Verifies point size used to render points is taken from" |
| " the right stage") |
| , m_fbo_id(0) |
| , m_to_id(0) |
| , m_vao_id(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Deinitializes all ES objects created for the test. */ |
| void TessellationShaderPointsgl_PointSize::deinit() |
| { |
| /** Call base class' deinit() function */ |
| TestCaseBase::deinit(); |
| |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| /* Disable point size */ |
| gl.disable(GL_PROGRAM_POINT_SIZE); |
| } |
| |
| /* Reset the program object */ |
| gl.useProgram(0); |
| |
| /* Revert GL_PATCH_VERTICES_EXT to default value */ |
| gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 3); |
| |
| /* Unbind vertex array object */ |
| gl.bindVertexArray(0); |
| |
| /* Deinitialize test-specific objects */ |
| for (_tests_iterator it = m_tests.begin(); it != m_tests.end(); ++it) |
| { |
| const _test_descriptor& test = *it; |
| |
| if (test.fs_id != 0) |
| { |
| gl.deleteShader(test.fs_id); |
| } |
| |
| if (test.gs_id != 0) |
| { |
| gl.deleteShader(test.gs_id); |
| } |
| |
| if (test.po_id != 0) |
| { |
| gl.deleteProgram(test.po_id); |
| } |
| |
| if (test.tes_id != 0) |
| { |
| gl.deleteShader(test.tes_id); |
| } |
| |
| if (test.tcs_id != 0) |
| { |
| gl.deleteShader(test.tcs_id); |
| } |
| |
| if (test.vs_id != 0) |
| { |
| gl.deleteShader(test.vs_id); |
| } |
| } |
| m_tests.clear(); |
| |
| if (m_fbo_id != 0) |
| { |
| gl.deleteFramebuffers(1, &m_fbo_id); |
| |
| m_fbo_id = 0; |
| } |
| |
| if (m_to_id != 0) |
| { |
| gl.deleteTextures(1, &m_to_id); |
| |
| m_to_id = 0; |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| } |
| |
| /** Initializes all ES objects that will be used for the test. */ |
| void TessellationShaderPointsgl_PointSize::initTest() |
| { |
| /* The test should only execute if maximum point size is at least 2 */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| glw::GLint gl_max_point_size_value[2] = { 0 }; |
| const int min_max_point_size = 2; |
| |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| gl.getIntegerv(GL_POINT_SIZE_RANGE, gl_max_point_size_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() for GL_POINT_SIZE_RANGE failed."); |
| } |
| else |
| { |
| gl.getIntegerv(GL_ALIASED_POINT_SIZE_RANGE, gl_max_point_size_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() for GL_ALIASED_POINT_SIZE_RANGE failed."); |
| } |
| |
| if (gl_max_point_size_value[1] < min_max_point_size) |
| { |
| throw tcu::NotSupportedError("Maximum point size is lower than 2."); |
| } |
| |
| /* The test requires EXT_tessellation_shader, EXT_tessellation_shader_point_size */ |
| if (!m_is_tessellation_shader_supported || !m_is_tessellation_shader_point_size_supported) |
| { |
| throw tcu::NotSupportedError("At least one of the required extensions is not supported."); |
| } |
| |
| /* Initialize vertex array object */ |
| gl.genVertexArrays(1, &m_vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate vertex array object"); |
| |
| gl.bindVertexArray(m_vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding vertex array object!"); |
| |
| /* Initialize fs+gs+vs test descriptor */ |
| if (m_is_geometry_shader_extension_supported) |
| { |
| _test_descriptor pass_fs_gs_tes_vs; |
| |
| /* Configure shader bodies */ |
| pass_fs_gs_tes_vs.fs_body = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "in vec4 color;\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result = color;\n" |
| "}\n"; |
| |
| pass_fs_gs_tes_vs.gs_body = "${VERSION}\n" |
| "\n" |
| "${GEOMETRY_SHADER_REQUIRE}\n" |
| "${GEOMETRY_POINT_SIZE_REQUIRE}\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(points, max_vertices=5) out;\n" |
| "\n" |
| "out vec4 color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " const float point_dx = 2.0 / 16.0 /* rendertarget width */;\n" |
| " const float point_dy = 2.0 / 16.0 /* rendertarget_height */;\n" |
| "\n" |
| /* Center */ |
| " color = vec4(0.1, 0.2, 0.3, 0.4);\n" |
| " gl_PointSize = 2.0;\n" |
| " gl_Position = vec4(point_dx + 0.0, point_dy + 0.0, 0.0, 1.0);\n" |
| " EmitVertex();\n" |
| "\n" |
| /* Top-left corner */ |
| " color = vec4(0.2, 0.3, 0.4, 0.5);\n" |
| " gl_PointSize = 2.0;\n" |
| " gl_Position = vec4(point_dx - 1.0, -point_dy + 1.0, 0.0, 1.0);\n" |
| " EmitVertex();\n" |
| "\n" |
| /* Top-right corner */ |
| " color = vec4(0.3, 0.4, 0.5, 0.6);\n" |
| " gl_PointSize = 2.0;\n" |
| " gl_Position = vec4(-point_dx + 1.0, -point_dy + 1.0, 0.0, 1.0);\n" |
| " EmitVertex();\n" |
| "\n" |
| /* Bottom-left corner */ |
| " color = vec4(0.4, 0.5, 0.6, 0.7);\n" |
| " gl_PointSize = 2.0;\n" |
| " gl_Position = vec4(point_dx - 1.0, point_dy - 1.0, 0.0, 1.0);\n" |
| " EmitVertex();\n" |
| "\n" |
| /* Bottom-right corner */ |
| " color = vec4(0.5, 0.6, 0.7, 0.8);\n" |
| " gl_PointSize = 2.0;\n" |
| " gl_Position = vec4(-point_dx + 1.0, point_dy - 1.0, 0.0, 1.0);\n" |
| " EmitVertex();\n" |
| "\n" |
| "}\n"; |
| |
| pass_fs_gs_tes_vs.tes_body = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "${TESSELLATION_POINT_SIZE_REQUIRE}\n" |
| "\n" |
| "layout(isolines, point_mode) in;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_PointSize = 0.1;\n" |
| "}\n"; |
| |
| pass_fs_gs_tes_vs.tcs_body = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "${TESSELLATION_POINT_SIZE_REQUIRE}\n" |
| "\n" |
| "layout(vertices=1) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_out[gl_InvocationID].gl_Position =\n" |
| " gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_out[gl_InvocationID].gl_PointSize =\n" |
| " gl_in[gl_InvocationID].gl_PointSize;\n" |
| "\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"; |
| |
| pass_fs_gs_tes_vs.vs_body = "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_PointSize = 0.01;\n" |
| "}\n"; |
| |
| pass_fs_gs_tes_vs.draw_call_count = 1; |
| |
| /* Store the descriptor in a vector that will be used by iterate() */ |
| m_tests.push_back(pass_fs_gs_tes_vs); |
| } /* if (m_is_geometry_shader_extension_supported) */ |
| |
| /* Initialize fs+te+vs test descriptor */ |
| if (m_is_tessellation_shader_supported) |
| { |
| _test_descriptor pass_fs_tes_vs; |
| |
| /* Configure shader bodies */ |
| pass_fs_tes_vs.fs_body = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "in vec4 result_color;\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result = result_color;\n" |
| "}\n"; |
| |
| pass_fs_tes_vs.tes_body = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "${TESSELLATION_POINT_SIZE_REQUIRE}\n" |
| "\n" |
| "layout(isolines, point_mode) in;\n" |
| "\n" |
| "in vec4 tcColor[];\n" |
| "out vec4 result_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_PointSize = 2.0;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " result_color = tcColor[0];\n" |
| "}\n"; |
| |
| pass_fs_tes_vs.tcs_body = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "${TESSELLATION_POINT_SIZE_REQUIRE}\n" |
| "\n" |
| "layout(vertices=1) out;\n" |
| "\n" |
| "in vec4 color[];\n" |
| "out vec4 tcColor[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " tcColor[gl_InvocationID] = color[gl_InvocationID];\n" |
| " gl_out[gl_InvocationID].gl_Position =\n" |
| " gl_in[gl_InvocationID].gl_Position;\n" |
| " gl_out[gl_InvocationID].gl_PointSize =\n" |
| " gl_in[gl_InvocationID].gl_PointSize;\n" |
| "\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"; |
| |
| pass_fs_tes_vs.vs_body = "${VERSION}\n" |
| "\n" |
| "out vec4 color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " const float point_dx = 2.0 / 16.0 /* rendertarget width */;\n" |
| " const float point_dy = 2.0 / 16.0 /* rendertarget_height */;\n" |
| "\n" |
| " gl_PointSize = 0.1;\n" |
| "\n" |
| " switch (gl_VertexID)\n" |
| " {\n" |
| " case 0:\n" |
| " {\n" |
| /* Center */ |
| " color = vec4(0.1, 0.2, 0.3, 0.4);\n" |
| " gl_Position = vec4(point_dx + 0.0, point_dy + 0.0, 0.0, 1.0);\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| "\n" |
| " case 1:\n" |
| " {\n" |
| /* Top-left corner */ |
| " color = vec4(0.2, 0.3, 0.4, 0.5);\n" |
| " gl_Position = vec4(point_dx - 1.0, -point_dy + 1.0, 0.0, 1.0);\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| "\n" |
| " case 2:\n" |
| " {\n" |
| /* Top-right corner */ |
| " color = vec4(0.3, 0.4, 0.5, 0.6);\n" |
| " gl_Position = vec4(-point_dx + 1.0, -point_dy + 1.0, 0.0, 1.0);\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| "\n" |
| " case 3:\n" |
| " {\n" |
| /* Bottom-left corner */ |
| " color = vec4(0.4, 0.5, 0.6, 0.7);\n" |
| " gl_Position = vec4(point_dx - 1.0, point_dy - 1.0, 0.0, 1.0);\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| "\n" |
| " case 4:\n" |
| " {\n" |
| /* Bottom-right corner */ |
| " color = vec4(0.5, 0.6, 0.7, 0.8);\n" |
| " gl_Position = vec4(-point_dx + 1.0, point_dy - 1.0, 0.0, 1.0);\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| " }\n" |
| "}\n"; |
| |
| pass_fs_tes_vs.draw_call_count = 5; /* points in total */ |
| |
| /* Store the descriptor in a vector that will be used by iterate() */ |
| m_tests.push_back(pass_fs_tes_vs); |
| } /* if (m_is_tessellation_shader_supported) */ |
| |
| /* Set up a color texture we will be rendering to */ |
| gl.genTextures(1, &m_to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed"); |
| |
| gl.bindTexture(GL_TEXTURE_2D, m_to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed"); |
| |
| gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, GL_RGBA8, m_rt_width, m_rt_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed"); |
| |
| /* Set up a FBO we'll use for rendering */ |
| gl.genFramebuffers(1, &m_fbo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed"); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed"); |
| |
| gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed"); |
| |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| /* Enable point size */ |
| gl.enable(GL_PROGRAM_POINT_SIZE); |
| } |
| |
| /* We're good to execute the test! */ |
| } |
| |
| /** 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 TessellationShaderPointsgl_PointSize::iterate(void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| initTest(); |
| |
| gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteriEXT() failed"); |
| |
| /* Iterate through all test descriptors.. */ |
| for (_tests_iterator test_iterator = m_tests.begin(); test_iterator != m_tests.end(); test_iterator++) |
| { |
| _test_descriptor& test = *test_iterator; |
| |
| /* Generate all shader objects we'll need */ |
| if (test.fs_body != NULL) |
| { |
| test.fs_id = gl.createShader(GL_FRAGMENT_SHADER); |
| } |
| |
| if (test.gs_body != NULL) |
| { |
| test.gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER); |
| } |
| |
| if (test.tes_body != NULL) |
| { |
| test.tes_id = gl.createShader(m_glExtTokens.TESS_EVALUATION_SHADER); |
| } |
| |
| if (test.tcs_body != NULL) |
| { |
| test.tcs_id = gl.createShader(m_glExtTokens.TESS_CONTROL_SHADER); |
| } |
| |
| if (test.vs_body != NULL) |
| { |
| test.vs_id = gl.createShader(GL_VERTEX_SHADER); |
| } |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed"); |
| |
| /* Generate a test program object before we continue */ |
| test.po_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed"); |
| |
| bool link_success = |
| buildProgram(test.po_id, test.fs_id, test.fs_id ? 1 : 0, &test.fs_body, test.gs_id, test.gs_id ? 1 : 0, |
| &test.gs_body, test.tes_id, test.tes_id ? 1 : 0, &test.tes_body, test.tcs_id, |
| test.tcs_id ? 1 : 0, &test.tcs_body, test.vs_id, test.vs_id ? 1 : 0, &test.vs_body); |
| |
| if (!link_success) |
| { |
| TCU_FAIL("Program linking failed"); |
| } |
| |
| /* Prepare for rendering */ |
| gl.clearColor(0.0f /* red */, 0.0f /* green */, 0.0f /* blue */, 0.0f /* alpha */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor() failed"); |
| |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glClear(GL_COLOR_BUFFER_BIT) failed"); |
| |
| gl.viewport(0 /* x */, 0 /* x */, m_rt_width, m_rt_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed"); |
| |
| gl.useProgram(test.po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed"); |
| |
| /* Render */ |
| gl.drawArrays(m_glExtTokens.PATCHES, 0 /* first */, test.draw_call_count); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed"); |
| |
| /* Read back the rendered data */ |
| unsigned char buffer[m_rt_width * m_rt_height * 4 /* components */] = { 0 }; |
| |
| gl.readPixels(0, /* x */ |
| 0, /* y */ |
| m_rt_width, m_rt_height, GL_RGBA, GL_UNSIGNED_BYTE, buffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed"); |
| |
| /* Verify all 5 points were rendered correctly */ |
| const float epsilon = (float)1.0f / 255.0f; |
| const unsigned int pixel_size = 4; /* components, GL_UNSIGNED_BYTE */ |
| const float point_data[] = { |
| /* x */ /* y */ /* r */ /* g */ /* b */ /* a */ |
| 0.5f, 0.5f, 0.1f, 0.2f, 0.3f, 0.4f, /* center */ |
| 0.0f, 1.0f, 0.2f, 0.3f, 0.4f, 0.5f, /* top-left */ |
| 1.0f, 1.0f, 0.3f, 0.4f, 0.5f, 0.6f, /* top-right */ |
| 0.0f, 0.0f, 0.4f, 0.5f, 0.6f, 0.7f, /* bottom-left */ |
| 1.0f, 0.0f, 0.5f, 0.6f, 0.7f, 0.8f /* bottom-right */ |
| }; |
| const unsigned int row_size = pixel_size * m_rt_width; |
| const unsigned int n_fields_per_point = 6; |
| const unsigned int n_points = sizeof(point_data) / sizeof(point_data[0]) / n_fields_per_point; |
| |
| for (unsigned int n_point = 0; n_point < n_points; ++n_point) |
| { |
| int x = (int)(point_data[n_point * n_fields_per_point + 0] * float(m_rt_width - 1) + 0.5f); |
| int y = (int)(point_data[n_point * n_fields_per_point + 1] * float(m_rt_height - 1) + 0.5f); |
| float expected_color_r = point_data[n_point * n_fields_per_point + 2]; |
| float expected_color_g = point_data[n_point * n_fields_per_point + 3]; |
| float expected_color_b = point_data[n_point * n_fields_per_point + 4]; |
| float expected_color_a = point_data[n_point * n_fields_per_point + 5]; |
| |
| const unsigned char* rendered_color_ubyte_ptr = buffer + row_size * y + x * pixel_size; |
| const float rendered_color_r = float(rendered_color_ubyte_ptr[0]) / 255.0f; |
| const float rendered_color_g = float(rendered_color_ubyte_ptr[1]) / 255.0f; |
| const float rendered_color_b = float(rendered_color_ubyte_ptr[2]) / 255.0f; |
| const float rendered_color_a = float(rendered_color_ubyte_ptr[3]) / 255.0f; |
| |
| /* Compare the pixels */ |
| if (de::abs(expected_color_r - rendered_color_r) > epsilon || |
| de::abs(expected_color_g - rendered_color_g) > epsilon || |
| de::abs(expected_color_b - rendered_color_b) > epsilon || |
| de::abs(expected_color_a - rendered_color_a) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Pixel data comparison failed; expected: " |
| << "(" << expected_color_r << ", " << expected_color_g << ", " << expected_color_b |
| << ", " << expected_color_a << ") rendered: " |
| << "(" << rendered_color_r << ", " << rendered_color_g << ", " << rendered_color_b |
| << ", " << rendered_color_a << ") epsilon: " << epsilon << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Pixel data comparison failed"); |
| } |
| } /* for (all points) */ |
| } /* for (all tests) */ |
| |
| /* All done */ |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderPointsVerification::TessellationShaderPointsVerification(Context& context, |
| const ExtParameters& extParams) |
| : TestCaseBase(context, extParams, "points_verification", |
| "Verifies points generated by the tessellator unit do not duplicate " |
| "and that their amount is correct") |
| , m_utils(DE_NULL) |
| , m_vao_id(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /* Deinitializes all ES Instances generated for the test */ |
| void TessellationShaderPointsVerification::deinit() |
| { |
| /* Call base class' deinit() */ |
| TestCaseBase::deinit(); |
| |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Unbind vertex array object */ |
| gl.bindVertexArray(0); |
| |
| /* Delete utils instances */ |
| if (m_utils != DE_NULL) |
| { |
| delete m_utils; |
| |
| m_utils = DE_NULL; |
| } |
| |
| /* Delete vertex array object */ |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| } |
| |
| /** Initializes ES objects necessary to run the test. */ |
| void TessellationShaderPointsVerification::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Skip if required extensions are not supported. */ |
| if (!m_is_tessellation_shader_supported) |
| { |
| throw tcu::NotSupportedError(TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED); |
| } |
| |
| /* Initialize and bind vertex array object */ |
| gl.genVertexArrays(1, &m_vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate vertex array object"); |
| |
| gl.bindVertexArray(m_vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding vertex array object!"); |
| |
| /* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value */ |
| glw::GLint gl_max_tess_gen_level_value = 0; |
| |
| gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname"); |
| |
| /* Initialize all test iterations */ |
| const _tessellation_primitive_mode primitive_modes[] = { TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS, |
| TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES, |
| TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES }; |
| const unsigned int n_primitive_modes = sizeof(primitive_modes) / sizeof(primitive_modes[0]); |
| |
| const _tessellation_shader_vertex_spacing vertex_spacings[] = { |
| TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD, TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, |
| TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_EVEN, |
| }; |
| const unsigned int n_vertex_spacings = sizeof(vertex_spacings) / sizeof(vertex_spacings[0]); |
| |
| for (unsigned int n_primitive_mode = 0; n_primitive_mode < n_primitive_modes; ++n_primitive_mode) |
| { |
| _tessellation_levels_set levels_set; |
| _tessellation_primitive_mode primitive_mode = primitive_modes[n_primitive_mode]; |
| |
| levels_set = TessellationShaderUtils::getTessellationLevelSetForPrimitiveMode( |
| primitive_mode, gl_max_tess_gen_level_value, |
| TESSELLATION_LEVEL_SET_FILTER_INNER_AND_OUTER_LEVELS_USE_DIFFERENT_VALUES); |
| |
| for (unsigned int n_vertex_spacing = 0; n_vertex_spacing < n_vertex_spacings; ++n_vertex_spacing) |
| { |
| _tessellation_shader_vertex_spacing vertex_spacing = vertex_spacings[n_vertex_spacing]; |
| |
| for (_tessellation_levels_set_const_iterator levels_set_iterator = levels_set.begin(); |
| levels_set_iterator != levels_set.end(); levels_set_iterator++) |
| { |
| const _tessellation_levels& levels = *levels_set_iterator; |
| |
| /* Skip border cases that this test cannot handle */ |
| if ((primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS || |
| primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES) && |
| vertex_spacing == TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD && |
| (levels.inner[0] <= 1 || levels.inner[1] <= 1)) |
| { |
| continue; |
| } |
| |
| /* Initialize a test run descriptor for the iteration-specific properties */ |
| _run run; |
| |
| memcpy(run.inner, levels.inner, sizeof(run.inner)); |
| memcpy(run.outer, levels.outer, sizeof(run.outer)); |
| |
| run.primitive_mode = primitive_mode; |
| run.vertex_spacing = vertex_spacing; |
| |
| m_runs.push_back(run); |
| } /* for (all level sets) */ |
| } /* for (all vertex spacing modes) */ |
| } /* for (all primitive modes) */ |
| |
| /* Initialize utils instance. |
| */ |
| m_utils = new TessellationShaderUtils(gl, this); |
| } |
| |
| /** 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 TessellationShaderPointsVerification::iterate(void) |
| { |
| initTest(); |
| |
| /* 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 the test descriptors */ |
| for (std::vector<_run>::const_iterator run_iterator = m_runs.begin(); run_iterator != m_runs.end(); run_iterator++) |
| { |
| const _run& run = *run_iterator; |
| std::vector<char> run_data; |
| unsigned int run_n_vertices = 0; |
| |
| run_data = m_utils->getDataGeneratedByTessellator(run.inner, true, /* point_mode */ |
| run.primitive_mode, TESSELLATION_SHADER_VERTEX_ORDERING_CCW, |
| run.vertex_spacing, run.outer); |
| |
| run_n_vertices = m_utils->getAmountOfVerticesGeneratedByTessellator(run.primitive_mode, run.inner, run.outer, |
| run.vertex_spacing, true); /* point_mode */ |
| |
| /* First, make sure a valid amount of duplicate vertices was found for a single data set */ |
| verifyCorrectAmountOfDuplicateVertices(run, &run_data[0], run_n_vertices); |
| |
| /* Now, verify that amount of generated vertices is correct, given |
| * tessellation shader stage configuration */ |
| verifyCorrectAmountOfVertices(run, &run_data[0], run_n_vertices); |
| } /* for (all tests) */ |
| |
| /* All done */ |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Verifies that a correct amount of vertices was generated, given test iteration-specific properties. |
| * Throws a TestError exception in if an incorrect amount of vertices was generated by the tessellator. |
| * |
| * @param run Run descriptor. |
| * @param run_data Data generated for the run. |
| * @param run_n_vertices Amount of vertices present at @param run_data. |
| */ |
| void TessellationShaderPointsVerification::verifyCorrectAmountOfVertices(const _run& run, const void* run_data, |
| unsigned int run_n_vertices) |
| { |
| (void)run_data; |
| |
| const float epsilon = 1e-5f; |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| unsigned int n_expected_vertices = 0; |
| float post_vs_inner_tess_levels[2] = { 0.0f }; |
| float post_vs_outer_tess_levels[4] = { 0.0f }; |
| |
| /* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value*/ |
| glw::GLint gl_max_tess_gen_level_value = 0; |
| |
| gl.getIntegerv(m_glExtTokens.MAX_TESS_GEN_LEVEL, &gl_max_tess_gen_level_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed for GL_MAX_TESS_GEN_LEVEL_EXT pname"); |
| |
| /* Determine vertex spacing that the tessellator should have used for current primitive mode */ |
| glw::GLfloat actual_inner_levels[2] = { 0.0f }; |
| _tessellation_shader_vertex_spacing actual_vs_mode = run.vertex_spacing; |
| glw::GLfloat clamped_inner_levels[2] = { 0.0f }; |
| |
| memcpy(actual_inner_levels, run.inner, sizeof(run.inner)); |
| |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| run.vertex_spacing, actual_inner_levels[0], gl_max_tess_gen_level_value, clamped_inner_levels + 0, |
| DE_NULL); /* out_clamped_and_rounded */ |
| |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| run.vertex_spacing, actual_inner_levels[1], gl_max_tess_gen_level_value, clamped_inner_levels + 1, |
| DE_NULL); /* out_clamped_and_rounded */ |
| |
| if (run.primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES) |
| { |
| /* For isolines tessellation, outer[1] is subdivided as per specified vertex spacing as specified. |
| * outer[0] should be subdivided using equal vertex spacing. |
| * |
| * This is owing to the following language in the spec (* marks important subtleties): |
| * |
| * The *u==0* and *u==1* edges of the rectangle are subdivided according to the first outer |
| * tessellation level. For the purposes of *this* subdivision, the tessellation spacing mode |
| * is ignored and treated as "equal_spacing". |
| */ |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, |
| run.outer[0], gl_max_tess_gen_level_value, |
| DE_NULL, /* out_clamped */ |
| post_vs_outer_tess_levels); |
| |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| actual_vs_mode, run.outer[1], gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| post_vs_outer_tess_levels + 1); |
| } |
| |
| if (run.primitive_mode == TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS) |
| { |
| /* As per extension spec: |
| * |
| * if either clamped inner tessellation level is one, that tessellation level |
| * is treated as though it were originally specified as 1+epsilon, which would |
| * rounded up to result in a two- or three-segment subdivision according to the |
| * tessellation spacing. |
| * |
| **/ |
| if (de::abs(clamped_inner_levels[0] - 1.0f) < epsilon) |
| { |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| run.vertex_spacing, clamped_inner_levels[0] + 1.0f, /* epsilon */ |
| gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| actual_inner_levels + 0); |
| } |
| |
| if (de::abs(clamped_inner_levels[1] - 1.0f) < epsilon) |
| { |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| run.vertex_spacing, clamped_inner_levels[1] + 1.0f, /* epsilon */ |
| gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| actual_inner_levels + 1); |
| } |
| } |
| |
| /* Retrieve tessellation level values, taking vertex spacing setting into account */ |
| for (int n = 0; n < 2 /* inner tessellation level values */; ++n) |
| { |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| actual_vs_mode, actual_inner_levels[n], gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| post_vs_inner_tess_levels + n); |
| } |
| |
| if (run.primitive_mode != TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES) |
| { |
| for (int n = 0; n < 4 /* outer tessellation level values */; ++n) |
| { |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| actual_vs_mode, run.outer[n], gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| post_vs_outer_tess_levels + n); |
| } |
| } |
| |
| /* Calculate amount of vertices that should be generated in point mode */ |
| switch (run.primitive_mode) |
| { |
| case TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES: |
| { |
| n_expected_vertices = int(post_vs_outer_tess_levels[0]) * int(post_vs_outer_tess_levels[1] + 1); |
| |
| break; |
| } |
| |
| case TESSELLATION_SHADER_PRIMITIVE_MODE_QUADS: |
| { |
| n_expected_vertices = /* outer quad */ |
| int(post_vs_outer_tess_levels[0]) + int(post_vs_outer_tess_levels[1]) + int(post_vs_outer_tess_levels[2]) + |
| int(post_vs_outer_tess_levels[3]) + |
| /* inner quad */ |
| (int(post_vs_inner_tess_levels[0]) - 1) * (int(post_vs_inner_tess_levels[1]) - 1); |
| |
| break; |
| } |
| |
| case TESSELLATION_SHADER_PRIMITIVE_MODE_TRIANGLES: |
| { |
| /* If the first inner tessellation level and all three outer tessellation |
| * levels are exactly one after clamping and rounding, only a single triangle |
| * with (u,v,w) coordinates of (0,0,1), (1,0,0), and (0,1,0) is generated. |
| */ |
| if (de::abs(run.inner[0] - 1.0f) < epsilon && de::abs(run.outer[0] - 1.0f) < epsilon && |
| de::abs(run.outer[1] - 1.0f) < epsilon && de::abs(run.outer[2] - 1.0f) < epsilon) |
| { |
| n_expected_vertices = 3; |
| } |
| else |
| { |
| /* If the inner tessellation level is one and any of the outer tessellation |
| * levels is greater than one, the inner tessellation level is treated as |
| * though it were originally specified as 1+epsilon and will be rounded up to |
| * result in a two- or three-segment subdivision according to the |
| * tessellation spacing. |
| */ |
| if (de::abs(run.inner[0] - 1.0f) < epsilon && |
| (run.outer[0] > 1.0f || run.outer[1] > 1.0f || run.outer[2] > 1.0f)) |
| { |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| run.vertex_spacing, 2.0f, gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| post_vs_inner_tess_levels); |
| } |
| |
| /* Count vertices making up concentric inner triangles */ |
| n_expected_vertices = (int)post_vs_outer_tess_levels[0] + (int)post_vs_outer_tess_levels[1] + |
| (int)post_vs_outer_tess_levels[2]; |
| |
| for (int n = (int)post_vs_inner_tess_levels[0]; n >= 0; n -= 2) |
| { |
| /* For the outermost inner triangle, the inner triangle is degenerate - |
| * a single point at the center of the triangle -- if <n> is two. |
| */ |
| if (n == 2) |
| { |
| n_expected_vertices++; /* degenerate vertex */ |
| |
| break; |
| } |
| |
| /* If <n> is three, the edges of the inner triangle are not subdivided and is |
| * the final triangle in the set of concentric triangles. |
| */ |
| if (n == 3) |
| { |
| n_expected_vertices += 3 /* vertices per triangle */; |
| |
| break; |
| } |
| |
| /* Otherwise, each edge of the inner triangle is divided into <n>-2 segments, |
| * with the <n>-1 vertices of this subdivision produced by intersecting the |
| * inner edge with lines perpendicular to the edge running through the <n>-1 |
| * innermost vertices of the subdivision of the outer edge. |
| */ |
| if (n >= 2) |
| { |
| n_expected_vertices += (n - 2) * 3 /* triangle edges */; |
| } |
| else |
| { |
| /* Count in the degenerate point instead */ |
| n_expected_vertices++; |
| } |
| } /* for (all inner triangles) */ |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized primitive mode"); |
| } |
| } /* switch (test.primitive_mode) */ |
| |
| /* Compare two values */ |
| if (run_n_vertices != n_expected_vertices) |
| { |
| std::string primitive_mode = TessellationShaderUtils::getESTokenForPrimitiveMode(run.primitive_mode); |
| std::string vertex_spacing = TessellationShaderUtils::getESTokenForVertexSpacingMode(run.vertex_spacing); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << run_n_vertices |
| << " vertices were generated by the tessellator instead of expected " << n_expected_vertices |
| << " for primitive mode [" << primitive_mode << "], vertex spacing mode [" << vertex_spacing |
| << "], inner tessellation levels:[" << run.inner[0] << ", " << run.inner[1] |
| << "], outer tessellation levels:[" << run.outer[0] << ", " << run.outer[1] << ", " |
| << run.outer[2] << ", " << run.outer[3] << "], point mode enabled." |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Amount of vertices generated in point mode was incorrect"); |
| } /* if (test.n_vertices != n_expected_vertices) */ |
| } |
| |
| /** Verifies a valid amount of duplicate vertices is present in the set of coordinates |
| * generated by the tessellator, as described by user-provided test iteration descriptor. |
| * Throws a TestError exception if the vertex set does not meet the requirements. |
| * |
| * @param test Test iteration descriptor. |
| * @param run_data Data generated for the run. |
| * @param run_n_vertices Amount of vertices present at @param run_data. |
| **/ |
| void TessellationShaderPointsVerification::verifyCorrectAmountOfDuplicateVertices(const _run& run, const void* run_data, |
| unsigned int run_n_vertices) |
| { |
| const float epsilon = 1e-5f; |
| unsigned int n_duplicate_vertices = 0; |
| |
| for (unsigned int n_vertex_a = 0; n_vertex_a < run_n_vertices; ++n_vertex_a) |
| { |
| const float* vertex_a = (const float*)run_data + n_vertex_a * 3; /* components */ |
| |
| for (unsigned int n_vertex_b = n_vertex_a + 1; n_vertex_b < run_n_vertices; ++n_vertex_b) |
| { |
| const float* vertex_b = (const float*)run_data + n_vertex_b * 3; /* components */ |
| |
| if (de::abs(vertex_a[0] - vertex_b[0]) < epsilon && de::abs(vertex_a[1] - vertex_b[1]) < epsilon && |
| de::abs(vertex_a[2] - vertex_b[2]) < epsilon) |
| { |
| n_duplicate_vertices++; |
| } |
| } /* for (all vertices) */ |
| } /* for (all vertices) */ |
| |
| if (n_duplicate_vertices != 0) |
| { |
| std::string vertex_spacing = TessellationShaderUtils::getESTokenForVertexSpacingMode(run.vertex_spacing); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Duplicate vertices found for the following tesselelation" |
| " configuration: tessellation level:" |
| "[" |
| << run.inner[0] << ", " << run.inner[1] << "], " |
| "outer tessellation level:" |
| " [" |
| << run.outer[0] << ", " << run.outer[1] << ", " << run.outer[2] << ", " << run.outer[3] |
| << "], " |
| << "vertex spacing mode:[" << vertex_spacing.c_str() << "]" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Duplicate vertex found"); |
| } |
| } |
| |
| } /* namespace glcts */ |
