| /*------------------------------------------------------------------------- |
| * 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 "esextcTessellationShaderIsolines.hpp" |
| #include "esextcTessellationShaderUtils.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| namespace glcts |
| { |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShadersIsolines::TessellationShadersIsolines(Context &context, const ExtParameters &extParams) |
| : TestCaseBase(context, extParams, "isolines_tessellation", |
| "Verifies that the number of isolines generated during tessellation is " |
| "derived from the first outer tessellation level.\n" |
| "Makes sure that the number of segments in each isoline is derived from " |
| "the second outer tessellation level.\n" |
| "Makes sure that both inner tessellation levels and the 3rd and the 4th " |
| "outer tessellation levels do not affect the tessellation process.\n" |
| "Makes sure that equal_spacing vertex spacing mode does not affect amount" |
| " of generated isolines.\n" |
| "Makes sure no line is drawn between (0, 1) and (1, 1) in (u, v) domain.") |
| , m_irrelevant_tess_value_1(0.0f) |
| , m_irrelevant_tess_value_2(0.0f) |
| , m_utils_ptr(DE_NULL) |
| , m_vao_id(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Checks that amount of isolines generated during tessellation corresponds to the |
| * first outer tessellation level. |
| * |
| * This check needs not to operate over all test results generated for a particular |
| * vertex spacing mode. |
| * |
| * @param test_result Value of MAX_TESS_GEN_LEVEL token. For ES3.1 it will be equal to |
| * GL_MAX_TESS_GEN_LEVEL_EXT and for ES3.2 to GL_MAX_TESS_GEN_LEVEL. |
| * |
| **/ |
| void TessellationShadersIsolines::checkFirstOuterTessellationLevelEffect(_test_result &test_result, |
| const glw::GLenum glMaxTessGenLevelToken) |
| { |
| glcts::Context &context = test_result.parent->parent->getContext(); |
| const glw::Functions &gl = context.getRenderContext().getFunctions(); |
| glw::GLint gl_max_tess_gen_level_value = 0; |
| unsigned int n_isolines_expected = 0; |
| |
| if (test_result.n_vertices != 0) |
| { |
| /* Calculate how many isolines we're expecting */ |
| gl.getIntegerv(glMaxTessGenLevelToken, &gl_max_tess_gen_level_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname"); |
| |
| /* NOTE: Amount of isolines should always be based on TESSELLATION_SHADER_VERTEX_SPACING_EQUAL |
| * vertex spacing mode, even if a different one is defined in TE stage. |
| */ |
| float outer_zero_tess_level_clamped_rounded = 0.0f; |
| |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, test_result.parent->outer_tess_levels[0], |
| gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| &outer_zero_tess_level_clamped_rounded); |
| |
| n_isolines_expected = (unsigned int)outer_zero_tess_level_clamped_rounded; |
| |
| if (test_result.n_isolines != n_isolines_expected) |
| { |
| tcu::TestContext &test = test_result.parent->parent->getTestContext(); |
| |
| test.getLog() << tcu::TestLog::Message |
| << "Tessellator generated an invalid amount of isolines:" << test_result.n_isolines |
| << " instead of the expected amount:" << n_isolines_expected |
| << " for the following inner tessellation level configuration:" |
| << " (" << test_result.parent->inner_tess_levels[0] << ", " |
| << test_result.parent->inner_tess_levels[1] << ")" |
| << " and the following outer tesellation level configuration:" |
| << " (" << test_result.parent->outer_tess_levels[0] << ", " |
| << test_result.parent->outer_tess_levels[1] << ", " |
| << test_result.parent->outer_tess_levels[2] << ", " |
| << test_result.parent->outer_tess_levels[3] << ")" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid amount of isolines generated by tessellator"); |
| } |
| } /* if (test_run.n_vertices != 0) */ |
| } |
| |
| /** Makes sure that tessellation coordinates generated for inner+outer tessellation level |
| * configurations, between which irrelevant levels have been defined, are exactly the same. |
| * |
| * This check needs to operate over all test results generated for a particular |
| * vertex spacing mode. |
| * |
| * This function throws a TestError exception if the check fails. |
| **/ |
| void TessellationShadersIsolines::checkIrrelevantTessellationLevelsHaveNoEffect() |
| { |
| /* Make sure that two example data sets, for which irrelevant tessellation levels have |
| * been changed, are exactly the same |
| */ |
| DE_ASSERT(m_test_results.find(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL) != m_test_results.end()); |
| |
| const float epsilon = 1e-5f; |
| float irrelevant_tess_level1_rounded_clamped = 0.0f; |
| int irrelevant_tess_level1 = 0; |
| float irrelevant_tess_level2_rounded_clamped = 0.0f; |
| int irrelevant_tess_level2 = 0; |
| _test_results_iterator test_result_iterator_start = |
| m_test_results[TESSELLATION_SHADER_VERTEX_SPACING_EQUAL].begin(); |
| _test_results_iterator test_result_iterator_end = m_test_results[TESSELLATION_SHADER_VERTEX_SPACING_EQUAL].end(); |
| |
| /* Calculate two tessellation level values that we've used in init() */ |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| 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"); |
| |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, m_irrelevant_tess_value_1, gl_max_tess_gen_level_value, |
| DE_NULL, /* out_clamped */ |
| &irrelevant_tess_level1_rounded_clamped); |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, m_irrelevant_tess_value_2, gl_max_tess_gen_level_value, |
| DE_NULL, /* out_clamped */ |
| &irrelevant_tess_level2_rounded_clamped); |
| |
| irrelevant_tess_level1 = (int)irrelevant_tess_level1_rounded_clamped; |
| irrelevant_tess_level2 = (int)irrelevant_tess_level2_rounded_clamped; |
| |
| DE_ASSERT(de::abs(irrelevant_tess_level1 - irrelevant_tess_level2) > 0); |
| |
| /* Iterate through all test runs for equal spacing */ |
| for (_test_results_iterator test_result_iterator = test_result_iterator_start; |
| test_result_iterator != test_result_iterator_end; test_result_iterator++) |
| { |
| _test_result test_result = *test_result_iterator; |
| |
| if (test_result.irrelevant_tess_level == irrelevant_tess_level1) |
| { |
| _test_result test_result_reference = |
| findTestResult(irrelevant_tess_level2, test_result.outer1_tess_level, test_result.outer2_tess_level, |
| TESSELLATION_SHADER_VERTEX_SPACING_EQUAL); |
| |
| /* data for current test run and the reference one should match */ |
| DE_ASSERT(test_result.n_vertices == test_result_reference.n_vertices); |
| |
| for (unsigned int n_vertex = 0; n_vertex < test_result.n_vertices; ++n_vertex) |
| { |
| const float *vertex_data_1 = (&test_result.rendered_data[0]) + n_vertex * 3; /* components */ |
| const float *vertex_data_2 = (&test_result_reference.rendered_data[0]) + n_vertex * 3; /* components */ |
| |
| if (de::abs(vertex_data_1[0] - vertex_data_2[0]) > epsilon || |
| de::abs(vertex_data_1[1] - vertex_data_2[1]) > epsilon || |
| de::abs(vertex_data_1[2] - vertex_data_2[2]) > epsilon) |
| { |
| tcu::TestContext &test = test_result_iterator->parent->parent->getTestContext(); |
| |
| test.getLog() |
| << tcu::TestLog::Message |
| << "Tessellator generated non-matching data for different tessellation level configurations, " |
| "where only irrelevant tessellation levels have been changed; " |
| << " data generated for {inner:" |
| << " (" << test_result.parent->inner_tess_levels[0] << ", " |
| << test_result.parent->inner_tess_levels[1] << ")" |
| << " outer:" |
| << " (" << test_result.parent->outer_tess_levels[0] << ", " |
| << test_result.parent->outer_tess_levels[1] << ", " << test_result.parent->outer_tess_levels[2] |
| << ", " << test_result.parent->outer_tess_levels[3] << ")" |
| << "}:" |
| << " (" << vertex_data_1[0] << ", " << vertex_data_1[1] << ", " << vertex_data_1[2] << ")" |
| << ", data generated for {inner:" |
| << " (" << test_result_reference.parent->inner_tess_levels[0] << ", " |
| << test_result_reference.parent->inner_tess_levels[1] << ")" |
| << " outer:" |
| << " (" << test_result_reference.parent->outer_tess_levels[0] << ", " |
| << test_result_reference.parent->outer_tess_levels[1] << ", " |
| << test_result_reference.parent->outer_tess_levels[2] << ", " |
| << test_result_reference.parent->outer_tess_levels[3] << ")" |
| << "}:" |
| << " (" << vertex_data_2[0] << ", " << vertex_data_2[1] << ", " << vertex_data_2[2] << ")" |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid amount of unique line segments generated by tessellator"); |
| } /* if (equal and fractional_even data mismatch) */ |
| } /* for (all vertices) */ |
| } /* if (current test result's irrelelvant tessellation levels match what we're after) */ |
| } /* for (all test runs) */ |
| } |
| |
| /** Checks that the amount of line segments generated per isoline is as defined by |
| * second outer tessellation level. |
| * |
| * This check needs not to operate over all test results generated for a particular |
| * vertex spacing mode. |
| * |
| * This function throws a TestError exception if the check fails. |
| * |
| * @param test_result Test result descriptor to perform the check on. |
| * |
| **/ |
| void TessellationShadersIsolines::checkSecondOuterTessellationLevelEffect(_test_result &test_result, |
| const glw::GLenum glMaxTessGenLevelToken) |
| { |
| typedef float _line_segment_x; |
| typedef std::pair<_line_segment_x, _line_segment_x> _line_segment; |
| typedef std::vector<_line_segment> _line_segments; |
| typedef _line_segments::iterator _line_segments_iterator; |
| |
| glcts::Context &context = test_result.parent->parent->getContext(); |
| const float epsilon = 1e-5f; |
| _line_segments found_line_segments; |
| const glw::Functions &gl = context.getRenderContext().getFunctions(); |
| glw::GLint gl_max_tess_gen_level_value = 0; |
| float outer_tess_levels1_clamped_rounded = 0.0f; |
| unsigned int n_line_segments_per_isoline_expected = 0; |
| unsigned int n_unique_line_segments_found = 0; |
| |
| if (test_result.n_vertices != 0) |
| { |
| /* Calculate how many isolines we're expecting */ |
| gl.getIntegerv(glMaxTessGenLevelToken, &gl_max_tess_gen_level_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TESS_GEN_LEVEL_EXT pname"); |
| |
| TessellationShaderUtils::getTessellationLevelAfterVertexSpacing( |
| test_result.parent->vertex_spacing_mode, test_result.parent->outer_tess_levels[1], |
| gl_max_tess_gen_level_value, DE_NULL, /* out_clamped */ |
| &outer_tess_levels1_clamped_rounded); |
| |
| n_line_segments_per_isoline_expected = (unsigned int)outer_tess_levels1_clamped_rounded; |
| |
| /* Count unique line segments found in all the line segments making up the result data set. */ |
| for (unsigned int n_vertex = 0; n_vertex < test_result.n_vertices; |
| n_vertex += 2 /* vertices per line segment */) |
| { |
| bool was_line_segment_found = false; |
| const float *vertex1 = (&test_result.rendered_data[0]) + n_vertex * 3; /* components */ |
| float vertex1_x = vertex1[0]; |
| const float *vertex2 = (&test_result.rendered_data[0]) + (n_vertex + 1) * 3; /* components */ |
| float vertex2_x = vertex2[0]; |
| |
| for (_line_segments_iterator found_line_segments_iterator = found_line_segments.begin(); |
| found_line_segments_iterator != found_line_segments.end(); found_line_segments_iterator++) |
| { |
| float &found_vertex1_x = found_line_segments_iterator->first; |
| float &found_vertex2_x = found_line_segments_iterator->second; |
| |
| if (de::abs(found_vertex1_x - vertex1_x) < epsilon && de::abs(found_vertex2_x - vertex2_x) < epsilon) |
| { |
| was_line_segment_found = true; |
| |
| break; |
| } |
| } /* for (all found Ys) */ |
| |
| if (!was_line_segment_found) |
| { |
| found_line_segments.push_back(_line_segment(vertex1_x, vertex2_x)); |
| } |
| } /* for (all vertices) */ |
| |
| /* Compare the values */ |
| n_unique_line_segments_found = (unsigned int)found_line_segments.size(); |
| |
| if (n_unique_line_segments_found != n_line_segments_per_isoline_expected) |
| { |
| tcu::TestContext &test = test_result.parent->parent->getTestContext(); |
| |
| test.getLog() << tcu::TestLog::Message << "Tessellator generated an invalid amount of unique line segments:" |
| << n_unique_line_segments_found |
| << " instead of the expected amount:" << n_line_segments_per_isoline_expected |
| << " for the following inner tessellation level configuration:" |
| << " (" << test_result.parent->inner_tess_levels[0] << ", " |
| << test_result.parent->inner_tess_levels[1] << ")" |
| << " and the following outer tesellation level configuration:" |
| << " (" << test_result.parent->outer_tess_levels[0] << ", " |
| << test_result.parent->outer_tess_levels[1] << ", " |
| << test_result.parent->outer_tess_levels[2] << ", " |
| << test_result.parent->outer_tess_levels[3] << ")" |
| << " and the following vertex spacing mode: " << test_result.parent->vertex_spacing_mode |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid amount of unique line segments generated by tessellator"); |
| } |
| } /* if (test_run.n_vertices != 0) */ |
| } |
| |
| /** Verifies that no vertex making up any of the line segments outputted by the |
| * tessellator is located at height equal to -1. |
| * |
| * This check needs not to operate over all test results generated for a particular |
| * vertex spacing mode. |
| * |
| * This function throws a TestError exception if the check fails. |
| * |
| * @param test_result Test result descriptor to perform the check on. |
| * |
| **/ |
| void TessellationShadersIsolines::checkNoLineSegmentIsDefinedAtHeightOne(_test_result &test_result, glw::GLenum unused) |
| { |
| (void)unused; // suppress warning |
| |
| const float epsilon = 1e-5f; |
| |
| for (unsigned int n_vertex = 0; n_vertex < test_result.n_vertices; ++n_vertex) |
| { |
| const float *vertex = (&test_result.rendered_data[0]) + n_vertex * 3; /* components */ |
| |
| if (de::abs(vertex[1] - 1.0f) < epsilon) |
| { |
| tcu::TestContext &test = test_result.parent->parent->getTestContext(); |
| |
| test.getLog() << tcu::TestLog::Message << "Tessellator generated the following coordinate:" |
| << " (" << vertex[0] << ", " << vertex[1] << ", " << vertex[2] << ")" |
| << " for the following inner tessellation level configuration:" |
| << " (" << test_result.parent->inner_tess_levels[0] << ", " |
| << test_result.parent->inner_tess_levels[1] << ")" |
| << " and the following outer tesellation level configuration:" |
| << " (" << test_result.parent->outer_tess_levels[0] << ", " |
| << test_result.parent->outer_tess_levels[1] << ", " |
| << test_result.parent->outer_tess_levels[2] << ", " |
| << test_result.parent->outer_tess_levels[3] << ")" |
| << " which is invalid: Y must never be equal to 1." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid line segment generated by tessellator"); |
| } /* If the Y coordinate is set at 1 */ |
| } /* for (all vertices) */ |
| } |
| |
| /** Verifies that amount of isolines generated for the same inner+outer level |
| * configurations but for different vertex spacing modes is exactly the same. |
| * |
| * This check needs to operate over all test results generated for a particular |
| * vertex spacing mode. |
| * |
| * This function throws a TestError exception if the check fails. |
| * |
| **/ |
| void TessellationShadersIsolines::checkVertexSpacingDoesNotAffectAmountOfGeneratedIsolines() |
| { |
| DE_ASSERT(m_tests.find(TESSELLATION_SHADER_VERTEX_SPACING_EQUAL) != m_tests.end()); |
| |
| _test_results_iterator test_result_iterator_start = |
| m_test_results[TESSELLATION_SHADER_VERTEX_SPACING_EQUAL].begin(); |
| _test_results_iterator test_result_iterator_end = m_test_results[TESSELLATION_SHADER_VERTEX_SPACING_EQUAL].end(); |
| |
| for (_test_results_iterator test_result_iterator = test_result_iterator_start; |
| test_result_iterator != test_result_iterator_end; test_result_iterator++) |
| { |
| _test_result &test_result_equal = *test_result_iterator; |
| _test_result test_result_fe; |
| _test_result test_result_fo; |
| |
| /* Find a corresponding fractional_even test run descriptor */ |
| test_result_fe = |
| findTestResult(test_result_equal.irrelevant_tess_level, test_result_equal.outer1_tess_level, |
| test_result_equal.outer2_tess_level, TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_EVEN); |
| test_result_fo = |
| findTestResult(test_result_equal.irrelevant_tess_level, test_result_equal.outer1_tess_level, |
| test_result_equal.outer2_tess_level, TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD); |
| |
| /* Make sure the amounts match */ |
| if (test_result_equal.n_isolines != test_result_fe.n_isolines || |
| test_result_fe.n_isolines != test_result_fo.n_isolines) |
| { |
| tcu::TestContext &test = test_result_iterator->parent->parent->getTestContext(); |
| |
| test.getLog() << tcu::TestLog::Message |
| << "Tessellator generated different amount of isolines for EQUAL/" |
| "FRACTIONAL_EVEN/FRACTIONAL_ODD vertex spacing modes which is " |
| "invalid." |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid amount of unique isolines generated by tessellator"); |
| } /* if (amount of generated isolines does not match) */ |
| } /* for (all test runs) */ |
| } |
| |
| /** Counts amount of unique isolines in the captured data set and updates |
| * n_isolines field of user-provided @param test_result instance. |
| * |
| * @param test_result Test result instance to update. |
| */ |
| void TessellationShadersIsolines::countIsolines(_test_result &test_result) |
| { |
| const float epsilon = 1e-5f; |
| std::vector<float> found_ys; |
| |
| for (unsigned int n_vertex = 0; n_vertex < test_result.n_vertices; ++n_vertex) |
| { |
| bool was_y_found = false; |
| const float *vertex = (&test_result.rendered_data[0]) + n_vertex * 3; /* components */ |
| float vertex_y = vertex[1]; |
| |
| for (std::vector<float>::iterator found_ys_iterator = found_ys.begin(); found_ys_iterator != found_ys.end(); |
| found_ys_iterator++) |
| { |
| float &found_y = *found_ys_iterator; |
| |
| if (de::abs(vertex_y - found_y) < epsilon) |
| { |
| was_y_found = true; |
| |
| break; |
| } |
| } /* for (all found Ys) */ |
| |
| if (!was_y_found) |
| { |
| found_ys.push_back(vertex_y); |
| } |
| } /* for (all vertices) */ |
| |
| /* Store the value */ |
| test_result.n_isolines = (unsigned int)found_ys.size(); |
| } |
| |
| /** Deinitializes ES objects created for the test. */ |
| void TessellationShadersIsolines::deinit() |
| { |
| /* Call base class' deinit() */ |
| TestCaseBase::deinit(); |
| |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Reset GL_PATCH_VERTICES_EXT to default value */ |
| gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 3); |
| |
| /* Disable GL_RASTERIZER_DISCARD mode */ |
| gl.disable(GL_RASTERIZER_DISCARD); |
| |
| /* Unbind vertex array object */ |
| gl.bindVertexArray(0); |
| |
| /* Release Utilities instance */ |
| if (m_utils_ptr != NULL) |
| { |
| delete m_utils_ptr; |
| |
| m_utils_ptr = DE_NULL; |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| |
| /* Free the data structures we allocated for the test */ |
| m_tests.clear(); |
| } |
| |
| /** Retrieves test result structure for a particular set of properties. |
| * |
| * @param irrelevant_tess_level Irrelevant tessellation level the test result descriptor should be using. |
| * @param outer1_tess_level First outer tessellation level value the test result descriptor should be using. |
| * @param outer2_tess_level Second outer tessellation level value the test result descriptor should be using. |
| * @param vertex_spacing_mode Vertex spacing mode the test result descriptor should be using. |
| * |
| * This function throws a TestError exception if the test result descriptor the caller is after is not found. |
| * |
| * @return Test result descriptor of interest. |
| **/ |
| TessellationShadersIsolines::_test_result TessellationShadersIsolines::findTestResult( |
| _irrelevant_tess_level irrelevant_tess_level, _outer1_tess_level outer1_tess_level, |
| _outer2_tess_level outer2_tess_level, _tessellation_shader_vertex_spacing vertex_spacing_mode) |
| { |
| DE_ASSERT(m_tests.find(vertex_spacing_mode) != m_tests.end()); |
| |
| _test_results &test_results = m_test_results[vertex_spacing_mode]; |
| bool has_found = false; |
| TessellationShadersIsolines::_test_result result; |
| |
| for (_test_results_iterator test_results_iterator = test_results.begin(); |
| test_results_iterator != test_results.end(); test_results_iterator++) |
| { |
| if (test_results_iterator->irrelevant_tess_level == irrelevant_tess_level && |
| test_results_iterator->outer1_tess_level == outer1_tess_level && |
| test_results_iterator->outer2_tess_level == outer2_tess_level) |
| { |
| has_found = true; |
| result = *test_results_iterator; |
| |
| break; |
| } |
| } /* for (all test runs) */ |
| |
| if (!has_found) |
| { |
| TCU_FAIL("Requested test run was not found."); |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves rendering context associated with the test instance. |
| * |
| * @return Rendering context. |
| * |
| **/ |
| Context &TessellationShadersIsolines::getContext() |
| { |
| return m_context; |
| } |
| |
| /** Initializes ES objects necessary to run the test. */ |
| void TessellationShadersIsolines::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); |
| } |
| |
| /* Generate Utilities instance */ |
| m_utils_ptr = new TessellationShaderUtils(gl, this); |
| |
| /* Set up 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 reference tessellation values */ |
| const glw::GLfloat tess_levels[] = {-1.0f, 4.0f, float(gl_max_tess_gen_level_value) * 0.5f, |
| float(gl_max_tess_gen_level_value)}; |
| const unsigned int n_tess_levels = sizeof(tess_levels) / sizeof(tess_levels[0]); |
| |
| m_irrelevant_tess_value_1 = tess_levels[0]; |
| m_irrelevant_tess_value_2 = tess_levels[1]; |
| |
| /* Initialize all test passes. |
| * |
| * Make sure each relevant outer tessellation level iterates through values |
| * of our interest |
| */ |
| for (unsigned int outer1_tess_level_index = 0; outer1_tess_level_index < n_tess_levels; ++outer1_tess_level_index) |
| { |
| for (unsigned int outer2_tess_level_index = 0; outer2_tess_level_index < n_tess_levels; |
| ++outer2_tess_level_index) |
| { |
| /* To make the test execute in a reasonable time frame, just use |
| * two different levels for the outer tessellation levels */ |
| DE_STATIC_ASSERT(n_tess_levels >= 2); |
| |
| for (unsigned int other_tess_level_index = 0; other_tess_level_index < 2 /* see comment */; |
| ++other_tess_level_index) |
| { |
| float inner_tess_levels[2] = {tess_levels[other_tess_level_index], tess_levels[other_tess_level_index]}; |
| float outer_tess_levels[4] = {tess_levels[outer1_tess_level_index], |
| tess_levels[outer2_tess_level_index], tess_levels[other_tess_level_index], |
| tess_levels[other_tess_level_index]}; |
| |
| /* Finally, iterate over three vertex spacing modes */ |
| _tessellation_shader_vertex_spacing vertex_spacing_mode; |
| |
| const _tessellation_shader_vertex_spacing vs_modes[] = { |
| TESSELLATION_SHADER_VERTEX_SPACING_EQUAL, TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_EVEN, |
| TESSELLATION_SHADER_VERTEX_SPACING_FRACTIONAL_ODD}; |
| const int n_vs_modes = sizeof(vs_modes) / sizeof(vs_modes[0]); |
| |
| for (int n_vs_mode = 0; n_vs_mode < n_vs_modes; ++n_vs_mode) |
| { |
| vertex_spacing_mode = vs_modes[n_vs_mode]; |
| |
| _test_descriptor test; |
| |
| initTestDescriptor(vertex_spacing_mode, inner_tess_levels, outer_tess_levels, |
| tess_levels[other_tess_level_index], test); |
| |
| m_tests[vertex_spacing_mode].push_back(test); |
| } /* for (all available vertex spacing modes) */ |
| } /* for (all irrelevant tessellation levels) */ |
| } /* for (all defined second outer tessellation levels) */ |
| } /* for (all defined first outer tessellation levels) */ |
| } |
| |
| /** Initializes all ES objects necessary to run a specific test pass. |
| * |
| * @param vertex_spacing Vertex spacing mode to initialize the test descriptor with. |
| * @param inner_tess_levels Two FP values defining subsequent inner tessellation levels |
| * to be used for initializing the test descriptor. Must NOT be |
| * NULL. |
| * @param outer_tess_levels Four FP values defining subsequent outer tessellation levels |
| * to be used for initializing the test descriptor. Must NOT be |
| * NULL. |
| * @param irrelevant_tess_level Value to be used to set irrelevant tessellation level values. |
| * @param test Test descriptor to fill with IDs of initialized objects. |
| **/ |
| void TessellationShadersIsolines::initTestDescriptor(_tessellation_shader_vertex_spacing vertex_spacing, |
| const float *inner_tess_levels, const float *outer_tess_levels, |
| float irrelevant_tess_level, _test_descriptor &test) |
| { |
| memcpy(test.inner_tess_levels, inner_tess_levels, sizeof(test.inner_tess_levels)); |
| memcpy(test.outer_tess_levels, outer_tess_levels, sizeof(test.outer_tess_levels)); |
| |
| test.parent = this; |
| test.irrelevant_tess_level = irrelevant_tess_level; |
| test.vertex_spacing_mode = vertex_spacing; |
| } |
| |
| /** 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 TessellationShadersIsolines::iterate(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| |
| initTest(); |
| |
| /* We only need to use one vertex per so go for it */ |
| gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteriEXT() failed for GL_PATCH_VERTICES_EXT pname"); |
| |
| /* We don't need to rasterize anything in this test */ |
| gl.enable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) failed"); |
| |
| /* Retrieve GL_MAX_TESS_GEN_LEVEL_EXT value before we continue */ |
| 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."); |
| |
| /* To perform actual tests, we need to first retrieve the tessellated coordinates data. |
| * Run all tests configured and fill per-test buffer with the information. |
| **/ |
| for (_tests_per_vertex_spacing_map_iterator vs_key_iterator = m_tests.begin(); vs_key_iterator != m_tests.end(); |
| vs_key_iterator++) |
| { |
| for (_tests_const_iterator test_iterator = vs_key_iterator->second.begin(); |
| test_iterator != vs_key_iterator->second.end(); test_iterator++) |
| { |
| const _test_descriptor &test = *test_iterator; |
| |
| /* Capture tessellation data for considered configuration */ |
| unsigned int n_rendered_vertices = m_utils_ptr->getAmountOfVerticesGeneratedByTessellator( |
| TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES, test.inner_tess_levels, test.outer_tess_levels, |
| test.vertex_spacing_mode, false); /* is_point_mode_enabled */ |
| std::vector<char> rendered_data = m_utils_ptr->getDataGeneratedByTessellator( |
| test.inner_tess_levels, false, /* point mode */ |
| TESSELLATION_SHADER_PRIMITIVE_MODE_ISOLINES, TESSELLATION_SHADER_VERTEX_ORDERING_CCW, |
| test.vertex_spacing_mode, test.outer_tess_levels); |
| |
| /* Store the data in a test result descriptor */ |
| _test_result result; |
| |
| result.n_vertices = n_rendered_vertices; |
| result.parent = &test; |
| result.irrelevant_tess_level = (int)test.irrelevant_tess_level; |
| result.outer1_tess_level = (int)test.outer_tess_levels[0]; |
| result.outer2_tess_level = (int)test.outer_tess_levels[1]; |
| result.rendered_data.resize(rendered_data.size() / sizeof(float)); |
| if (0 != rendered_data.size()) |
| { |
| memcpy(&result.rendered_data[0], &rendered_data[0], rendered_data.size()); |
| } |
| if (result.rendered_data.size() > 0) |
| { |
| countIsolines(result); |
| } |
| |
| /* Store the test run descriptor. */ |
| m_test_results[test.vertex_spacing_mode].push_back(result); |
| } |
| } |
| |
| /* Now we can proceed with actual tests */ |
| /* (test 1): Make sure amount of isolines is determined by first outer tessellation level */ |
| runForAllTestResults(checkFirstOuterTessellationLevelEffect); |
| |
| /* (test 2): Make sure amount of line segments per height is determined by second outer |
| * tessellation level. |
| */ |
| runForAllTestResults(checkSecondOuterTessellationLevelEffect); |
| |
| /* (test 3): Make sure 3rd, 4th outer tessellation levels, as well as all inner tessellation |
| * levels have no impact on the tessellated coordinates */ |
| checkIrrelevantTessellationLevelsHaveNoEffect(); |
| |
| /* (test 4): Make sure no matter what vertex spacing is requested in TC stage, it is always |
| * equal_spacing that is applied. |
| */ |
| checkVertexSpacingDoesNotAffectAmountOfGeneratedIsolines(); |
| |
| /* (test 5): Make sure that no data set features a line segment at height of 1. */ |
| runForAllTestResults(checkNoLineSegmentIsDefinedAtHeightOne); |
| |
| /* All done */ |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** Calls the caller-provided function provided for each test result descriptor |
| * created during pre-computation stage. |
| * |
| * @param pProcessTestRun Function pointer to call. The function will be called |
| * exactly once for each cached test result descriptor. |
| * |
| **/ |
| void TessellationShadersIsolines::runForAllTestResults(PFNTESTRESULTPROCESSORPROC pProcessTestResult) |
| { |
| for (_test_results_per_vertex_spacing_map_iterator vs_key_iterator = m_test_results.begin(); |
| vs_key_iterator != m_test_results.end(); vs_key_iterator++) |
| { |
| for (_test_results_iterator test_results_iterator = vs_key_iterator->second.begin(); |
| test_results_iterator != vs_key_iterator->second.end(); test_results_iterator++) |
| { |
| _test_result &test_result = *test_results_iterator; |
| |
| pProcessTestResult(test_result, m_glExtTokens.MAX_TESS_GEN_LEVEL); |
| } /* for (all level3 keys) */ |
| } /* for (all vertex spacing modes) */ |
| } |
| |
| } /* namespace glcts */ |
