| /*------------------------------------------------------------------------- |
| * 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 "esextcTessellationShaderBarrier.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| namespace glcts |
| { |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| TessellationShaderBarrierTests::TessellationShaderBarrierTests(Context& context, const ExtParameters& extParams) |
| : TestCaseGroupBase(context, extParams, "tessellation_shader_tc_barriers", |
| "Verifies memory barrier work correctly when used in" |
| "tessellation control shaders") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /* Instantiates all tests and adds them as children to the node */ |
| void TessellationShaderBarrierTests::init(void) |
| { |
| addChild(new glcts::TessellationShaderBarrier1(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderBarrier2(m_context, m_extParams)); |
| addChild(new glcts::TessellationShaderBarrier3(m_context, m_extParams)); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's desricption |
| **/ |
| TessellationShaderBarrierTestCase::TessellationShaderBarrierTestCase(Context& context, const ExtParameters& extParams, |
| const char* name, const char* description) |
| : TestCaseBase(context, extParams, name, description) |
| , m_bo_id(0) |
| , m_fs_id(0) |
| , m_po_id(0) |
| , m_tcs_id(0) |
| , m_tes_id(0) |
| , m_vao_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Deinitializes all ES objects created for the test. */ |
| void TessellationShaderBarrierTestCase::deinit() |
| { |
| /** Call base class' deinit() function */ |
| TestCaseBase::deinit(); |
| |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Disable GL_RASTERIZER_DISCARD mode the test has enabled */ |
| gl.disable(GL_RASTERIZER_DISCARD); |
| |
| /* Bring back the original GL_PATCH_VERTICES_EXT setting */ |
| gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, 3); |
| |
| /* Revert buffer object bindings */ |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* buffer */); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, 0 /* buffer */); |
| |
| /* Unbind vertex array object */ |
| gl.bindVertexArray(0); |
| |
| /* Free all the objects that might have been initialized */ |
| if (m_bo_id != 0) |
| { |
| gl.deleteBuffers(1, &m_bo_id); |
| |
| m_bo_id = 0; |
| } |
| |
| 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_tcs_id != 0) |
| { |
| gl.deleteShader(m_tcs_id); |
| |
| m_tcs_id = 0; |
| } |
| |
| if (m_tes_id != 0) |
| { |
| gl.deleteShader(m_tes_id); |
| |
| m_tes_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_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 TessellationShaderBarrierTestCase::initTest() |
| { |
| /* The test requires EXT_tessellation_shader */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (!m_is_tessellation_shader_supported) |
| { |
| return; |
| } |
| |
| 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!"); |
| |
| /* Set up storage for XFB data. Also configure the BO binding points */ |
| const unsigned int xfb_data_size = getXFBBufferSize(); |
| |
| gl.genBuffers(1, &m_bo_id); |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_bo_id); |
| gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_data_size, NULL /* data */, GL_STATIC_DRAW); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up storage for XFB data"); |
| |
| /* Set up shader objects */ |
| m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); |
| m_tcs_id = gl.createShader(m_glExtTokens.TESS_CONTROL_SHADER); |
| m_tes_id = gl.createShader(m_glExtTokens.TESS_EVALUATION_SHADER); |
| m_vs_id = gl.createShader(GL_VERTEX_SHADER); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create shader objects"); |
| |
| /* Set up fragment shader body */ |
| const char* fs_body = "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| /* Set up tessellation control shader body */ |
| const char* tcs_body = getTCSCode(); |
| |
| /* Set up tessellation evaluation shader body */ |
| const char* tes_body = getTESCode(); |
| |
| /* Set up vertex shader body */ |
| const char* vs_body = getVSCode(); |
| |
| /* Set up a program object */ |
| m_po_id = gl.createProgram(); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() failed"); |
| |
| /* Set up XFB */ |
| const char** names = NULL; |
| int n_names = 0; |
| |
| getXFBProperties(&n_names, &names); |
| |
| gl.transformFeedbackVaryings(m_po_id, n_names, names, GL_INTERLEAVED_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() failed"); |
| |
| /* Try to compile and link all the shader objects */ |
| if (!buildProgram(m_po_id, m_fs_id, 1, &fs_body, m_tcs_id, 1, &tcs_body, m_tes_id, 1, &tes_body, m_vs_id, 1, |
| &vs_body)) |
| { |
| TCU_FAIL("Program linking failed"); |
| } |
| |
| /* All set! */ |
| } |
| |
| /** 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 TessellationShaderBarrierTestCase::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); |
| } |
| |
| /* Prepare for the draw call */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| glw::GLint drawcall_count = 0; |
| glw::GLenum drawcall_mode = GL_NONE; |
| glw::GLint drawcall_n_instances = 1; |
| glw::GLint n_patch_vertices = 0; |
| glw::GLenum tf_mode = GL_NONE; |
| |
| getDrawCallArgs(&drawcall_mode, &drawcall_count, &tf_mode, &n_patch_vertices, &drawcall_n_instances); |
| |
| gl.enable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) failed"); |
| |
| gl.patchParameteri(m_glExtTokens.PATCH_VERTICES, n_patch_vertices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteriEXT() failed"); |
| |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed"); |
| |
| gl.beginTransformFeedback(tf_mode); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() failed"); |
| { |
| if (drawcall_n_instances == 1) |
| { |
| gl.drawArrays(drawcall_mode, 0 /* first */, drawcall_count); |
| } |
| else |
| { |
| DE_ASSERT(drawcall_n_instances > 1); |
| |
| gl.drawArraysInstanced(drawcall_mode, 0 /* first */, drawcall_count, drawcall_n_instances); |
| } |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() or glDrawArraysInstanced() failed"); |
| } |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() failed"); |
| |
| /* Retrieve the data generated by XFB */ |
| int bo_size = getXFBBufferSize(); |
| const void* xfb_data = NULL; |
| |
| xfb_data = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */, bo_size, GL_MAP_READ_BIT); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() failed"); |
| |
| /* Verify the data */ |
| bool is_xfb_data_valid = verifyXFBBuffer(xfb_data); |
| |
| /* Unmap the buffer object */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() failed"); |
| |
| /* Set the test result, depending on the verification outcome */ |
| if (is_xfb_data_valid) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderBarrier1::TessellationShaderBarrier1(Context& context, const ExtParameters& extParams) |
| : TessellationShaderBarrierTestCase(context, extParams, "barrier_guarded_read_calls", |
| "Verifies invocation A can correctly read a per-vertex and" |
| " per-patch attribute modified by invocation B after a barrier() call") |
| , m_n_result_vertices(2048) |
| { |
| m_n_input_vertices = (m_n_result_vertices / 2 /* result points per isoline */) * 4 /* vertices per patch */; |
| } |
| |
| /** Retrieves arguments to be used for the rendering process. |
| * |
| * @param out_mode Deref will be used to store draw call mode. Must not be NULL. |
| * @param out_count Deref will be used to store count argument to be used for the draw call. |
| * Must not be NULL. |
| * @param out_tf_mode Deref will be used to store transform feed-back mode to be used for |
| * glBeginTransformFeedback() call, prior to issuing the draw call. Must |
| * not be NULL. |
| * @param out_n_patch_vertices Deref will be used to store GL_PATCH_VERTICES_EXT pname value, to be set with |
| * glPatchParameteriEXT() call prior to issuing the draw call. Must not be NULL. |
| * @param out_n_instances Deref will be used to store amount of instances to use for the draw call. |
| * Using a value of 1 will result in a glDrawArrays() call. Using values larger |
| * than 1 will trigger glDrawArraysInstanced() call. Values smaller than 1 are |
| * forbidden. |
| **/ |
| void TessellationShaderBarrier1::getDrawCallArgs(glw::GLenum* out_mode, glw::GLint* out_count, glw::GLenum* out_tf_mode, |
| glw::GLint* out_n_patch_vertices, glw::GLint* out_n_instances) |
| { |
| *out_count = m_n_input_vertices; |
| *out_mode = GL_PATCHES_EXT; |
| *out_n_instances = 1; |
| *out_n_patch_vertices = 4; |
| *out_tf_mode = GL_POINTS; |
| } |
| |
| /** Retrieves tessellation control shader body. |
| * |
| * @return TC stage shader body. |
| **/ |
| const char* TessellationShaderBarrier1::getTCSCode() |
| { |
| static const char* tcs_code = |
| "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n" |
| "flat in int vertex_id[];\n" |
| "\n" |
| "patch out int test_patch_value;\n" |
| " out ivec4 test_vector [];\n" |
| " out ivec4 test_vector2[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " if (gl_InvocationID == 0)\n" |
| " {\n" |
| " test_patch_value = vertex_id[0];\n" |
| " }\n" |
| "\n" |
| " test_vector[gl_InvocationID] = ivec4(vertex_id[gl_InvocationID],\n" |
| " vertex_id[gl_InvocationID] + 1,\n" |
| " vertex_id[gl_InvocationID] + 2,\n" |
| " vertex_id[gl_InvocationID] + 3);\n" |
| "\n" |
| " barrier();\n" |
| "\n" |
| " int next_invocation = (gl_InvocationID + 1) % 4;\n" |
| "\n" |
| " test_vector2[gl_InvocationID] = ivec4(test_vector[next_invocation].xyz, test_patch_value);\n" |
| "\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| |
| return tcs_code; |
| } |
| |
| /** Retrieves tessellation evaluation shader body. |
| * |
| * @return TE stage shader body. |
| **/ |
| const char* TessellationShaderBarrier1::getTESCode() |
| { |
| static const char* tes_code = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines, point_mode) in;\n" |
| "\n" |
| "in ivec4 test_vector2[];\n" |
| "\n" |
| "out ivec4 result_vector2;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " int base = gl_PrimitiveID * 4;\n" |
| "\n" |
| " if (test_vector2[0].x == (base + 1) && test_vector2[0].y == (base + 2) && " |
| "test_vector2[0].z == (base + 3) && test_vector2[0].w == (base + 0) &&\n" |
| " test_vector2[1].x == (base + 2) && test_vector2[1].y == (base + 3) && " |
| "test_vector2[1].z == (base + 4) && test_vector2[1].w == (base + 0) &&\n" |
| " test_vector2[2].x == (base + 3) && test_vector2[2].y == (base + 4) && " |
| "test_vector2[2].z == (base + 5) && test_vector2[2].w == (base + 0) &&\n" |
| " test_vector2[3].x == (base + 0) && test_vector2[3].y == (base + 1) && " |
| "test_vector2[3].z == (base + 2) && test_vector2[3].w == (base + 0) )\n" |
| " {\n" |
| " result_vector2 = ivec4(1);\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " result_vector2 = ivec4(0);\n" |
| " }\n" |
| "}\n"; |
| |
| return tes_code; |
| } |
| |
| /** Retrieves vertex shader body. |
| * |
| * @return Vertex shader body. |
| **/ |
| const char* TessellationShaderBarrier1::getVSCode() |
| { |
| static const char* vs_code = "${VERSION}\n" |
| "\n" |
| "flat out int vertex_id;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vertex_id = gl_VertexID;\n" |
| "}\n"; |
| |
| return vs_code; |
| } |
| |
| /** Retrieves amount of bytes that should be used for allocating storage space for |
| * a buffer object that will later be used to hold XFB result data. |
| * |
| * @return Amount of bytes required by the test. |
| */ |
| int TessellationShaderBarrier1::getXFBBufferSize() |
| { |
| return static_cast<int>(m_n_result_vertices * sizeof(int) * 4 /* components */ * 2 /* points per isoline */); |
| } |
| |
| /** Retrieves names of transform feedback varyings and amount of those. These should be used |
| * prior to link the test program object. |
| * |
| * @param out_n_names Deref will be used to store the number of names that @param out_names array |
| * holds. Must not be NULL. |
| * @param out_names Deref will be used to store a pointer to an array holding TF varying names; |
| * Must not be NULL. |
| **/ |
| void TessellationShaderBarrier1::getXFBProperties(int* out_n_names, const char*** out_names) |
| { |
| static const char* names[1] = { "result_vector2" }; |
| |
| *out_n_names = 1; |
| *out_names = names; |
| } |
| |
| /** Verifies data captured by XFB is correct. |
| * |
| * @param data Buffer holding the result XFB data. Must not be NULL. |
| * |
| * @return true if the result data is confirmed to be valid, false otherwise. |
| **/ |
| bool TessellationShaderBarrier1::verifyXFBBuffer(const void* data) |
| { |
| int* data_int = (int*)data; |
| |
| /* Run through all vertices */ |
| for (unsigned int n_vertex = 0; n_vertex < m_n_result_vertices; ++n_vertex) |
| { |
| int retrieved_x = data_int[n_vertex * 4]; |
| int retrieved_y = data_int[n_vertex * 4 + 1]; |
| int retrieved_z = data_int[n_vertex * 4 + 2]; |
| int retrieved_w = data_int[n_vertex * 4 + 3]; |
| |
| if (retrieved_x != 1 || retrieved_y != 1 || retrieved_z != 1 || retrieved_w != 1) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value returned: expected:[1, 1, 1, 1]" |
| << " retrieved: " |
| << "[" << retrieved_x << ", " << retrieved_y << ", " << retrieved_z << ", " |
| << retrieved_w << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid rendering result"); |
| } |
| } |
| |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderBarrier2::TessellationShaderBarrier2(Context& context, const ExtParameters& extParams) |
| : TessellationShaderBarrierTestCase(context, extParams, "barrier_guarded_write_calls", |
| "Verifies it is safe to write to the same per-patch output " |
| "from multiple TC invocations, as long as each write happens " |
| "in a separate phase.") |
| , m_n_result_vertices(2048) |
| { |
| m_n_input_vertices = (m_n_result_vertices / 2 /* result points per isoline */) * 4 /* vertices per patch */; |
| } |
| |
| /** Retrieves arguments to be used for the rendering process. |
| * |
| * @param out_mode Deref will be used to store draw call mode. Must not be NULL. |
| * @param out_count Deref will be used to store count argument to be used for the draw call. |
| * Must not be NULL. |
| * @param out_tf_mode Deref will be used to store transform feed-back mode to be used for |
| * glBeginTransformFeedback() call, prior to issuing the draw call. Must |
| * not be NULL. |
| * @param out_n_patch_vertices Deref will be used to store GL_PATCH_VERTICES_EXT pname value, to be set with |
| * glPatchParameteriEXT() call prior to issuing the draw call. Must not be NULL. |
| * @param out_n_instances Deref will be used to store amount of instances to use for the draw call. |
| * Using a value of 1 will result in a glDrawArrays() call. Using values larger |
| * than 1 will trigger glDrawArraysInstanced() call. Values smaller than 1 are |
| * forbidden. |
| **/ |
| void TessellationShaderBarrier2::getDrawCallArgs(glw::GLenum* out_mode, glw::GLint* out_count, glw::GLenum* out_tf_mode, |
| glw::GLint* out_n_patch_vertices, glw::GLint* out_n_instances) |
| { |
| *out_count = m_n_input_vertices; |
| *out_mode = GL_PATCHES_EXT; |
| *out_n_instances = 1; |
| *out_n_patch_vertices = 4; |
| *out_tf_mode = GL_POINTS; |
| } |
| |
| /** Retrieves tessellation control shader body. |
| * |
| * @return TC stage shader body. |
| **/ |
| const char* TessellationShaderBarrier2::getTCSCode() |
| { |
| static const char* tcs_code = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n" |
| " out float tcs_result[];\n" |
| "patch out int test_patch_value;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| /* Four invocations per input patch will be executed. Have the first one write its |
| * secret value to the output per-patch attribute. |
| */ |
| " if (gl_InvocationID == 0)\n" |
| " {\n" |
| " test_patch_value = 123;\n" |
| " }\n" |
| "\n" |
| " barrier();\n" |
| "\n" |
| /* Let's have the second invocation update the value at this point */ |
| " if (gl_InvocationID == 1)\n" |
| " {\n" |
| " test_patch_value = 234;\n" |
| " }\n" |
| "\n" |
| " barrier();\n" |
| "\n" |
| /* Finally, if this is invocation number one, check if test_patch_value |
| * stores a correct value. |
| */ |
| " tcs_result[gl_InvocationID] = 2.0;\n" |
| "\n" |
| " if (gl_InvocationID == 0)\n" |
| " {\n" |
| " if (test_patch_value == 234)\n" |
| " {\n" |
| " tcs_result[gl_InvocationID] = 1.0;\n" |
| " }\n" |
| " }\n" |
| "\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| |
| return tcs_code; |
| } |
| |
| /** Retrieves tessellation evaluation shader body. |
| * |
| * @return TE stage shader body. |
| **/ |
| const char* TessellationShaderBarrier2::getTESCode() |
| { |
| static const char* tes_code = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines, point_mode) in;\n" |
| "\n" |
| " in float tcs_result[];\n" |
| "\n" |
| "out float tes_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| /* TCS invocation order is undefined so take a maximum of all values we received */ |
| " if (tcs_result[0] == 1.0 &&\n" |
| " tcs_result[1] == 2.0 &&\n" |
| " tcs_result[2] == 2.0 &&\n" |
| " tcs_result[3] == 2.0)\n" |
| " {\n" |
| " tes_result = 1.0;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " tes_result = 0.0;\n" |
| " }\n" |
| "}\n"; |
| |
| return tes_code; |
| } |
| |
| /** Retrieves vertex shader body. |
| * |
| * @return Vertex shader body. |
| **/ |
| const char* TessellationShaderBarrier2::getVSCode() |
| { |
| static const char* vs_code = "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| return vs_code; |
| } |
| |
| /** Retrieves amount of bytes that should be used for allocating storage space for |
| * a buffer object that will later be used to hold XFB result data. |
| * |
| * @return Amount of bytes required by the test. |
| */ |
| int TessellationShaderBarrier2::getXFBBufferSize() |
| { |
| return static_cast<int>(m_n_result_vertices * sizeof(float) * 2 /* points per isoline */); |
| } |
| |
| /** Retrieves names of transform feedback varyings and amount of those. These should be used |
| * prior to link the test program object. |
| * |
| * @param out_n_names Deref will be used to store the number of names that @param out_names array |
| * holds. Must not be NULL. |
| * @param out_names Deref will be used to store a pointer to an array holding TF varying names; |
| * Must not be NULL. |
| **/ |
| void TessellationShaderBarrier2::getXFBProperties(int* out_n_names, const char*** out_names) |
| { |
| static const char* names[1] = { "tes_result" }; |
| |
| *out_n_names = 1; |
| *out_names = names; |
| } |
| |
| /** Verifies data captured by XFB is correct. |
| * |
| * @param data Buffer holding the result XFB data. Must not be NULL. |
| * |
| * @return true if the result data is confirmed to be valid, false otherwise. |
| **/ |
| bool TessellationShaderBarrier2::verifyXFBBuffer(const void* data) |
| { |
| float* data_float = (float*)data; |
| const float epsilon = (float)1e-5; |
| |
| /* Run through all vertices */ |
| for (unsigned int n_vertex = 0; n_vertex < m_n_result_vertices; ++n_vertex) |
| { |
| if (de::abs(data_float[n_vertex] - 1.0f /* valid result value */) > epsilon) |
| { |
| TCU_FAIL("Invalid data retrieved"); |
| } |
| } |
| |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| TessellationShaderBarrier3::TessellationShaderBarrier3(Context& context, const ExtParameters& extParams) |
| : TessellationShaderBarrierTestCase(context, extParams, "barrier_guarded_read_write_calls", |
| "Verifies it is safe to write to the same per-patch output " |
| "from multiple TC invocations, as long as each write happens " |
| "in a separate phase.") |
| , m_n_instances(10) /* as per test spec */ |
| , m_n_invocations(16) /* as per test spec */ |
| , m_n_patch_vertices(8) /* as per test spec */ |
| , m_n_patches_per_invocation(2) /* as per test spec */ |
| , m_n_result_vertices(2 /* result points per isoline */ * m_n_patches_per_invocation * m_n_invocations * |
| m_n_instances) |
| { |
| m_n_input_vertices = (m_n_result_vertices / 2 /* result points per isoline */) * 4 /* vertices per patch */; |
| } |
| |
| /** Retrieves arguments to be used for the rendering process. |
| * |
| * @param out_mode Deref will be used to store draw call mode. Must not be NULL. |
| * @param out_count Deref will be used to store count argument to be used for the draw call. |
| * Must not be NULL. |
| * @param out_tf_mode Deref will be used to store transform feed-back mode to be used for |
| * glBeginTransformFeedback() call, prior to issuing the draw call. Must |
| * not be NULL. |
| * @param out_n_patch_vertices Deref will be used to store GL_PATCH_VERTICES_EXT pname value, to be set with |
| * glPatchParameteriEXT() call prior to issuing the draw call. Must not be NULL. |
| * @param out_n_instances Deref will be used to store amount of instances to use for the draw call. |
| * Using a value of 1 will result in a glDrawArrays() call. Using values larger |
| * than 1 will trigger glDrawArraysInstanced() call. Values smaller than 1 are |
| * forbidden. |
| **/ |
| void TessellationShaderBarrier3::getDrawCallArgs(glw::GLenum* out_mode, glw::GLint* out_count, glw::GLenum* out_tf_mode, |
| glw::GLint* out_n_patch_vertices, glw::GLint* out_n_instances) |
| { |
| *out_count = m_n_patches_per_invocation * m_n_patch_vertices * m_n_instances; |
| *out_mode = GL_PATCHES_EXT; |
| *out_n_instances = m_n_instances; |
| *out_n_patch_vertices = m_n_patch_vertices; |
| *out_tf_mode = GL_POINTS; |
| } |
| |
| /** Retrieves tessellation control shader body. |
| * |
| * @return TC stage shader body. |
| **/ |
| const char* TessellationShaderBarrier3::getTCSCode() |
| { |
| static const char* tcs_code = |
| "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout (vertices = 16) out;\n" |
| "\n" |
| " out int tcs_data [];\n" |
| "patch out int tcs_patch_result[16];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| /* Even invocations should write their gl_InvocationID value to their per-vertex output. */ |
| " if ((gl_InvocationID % 2) == 0)\n" |
| " {\n" |
| " tcs_data[gl_InvocationID] = gl_InvocationID;\n" |
| " }\n" |
| "\n" |
| " barrier();\n" |
| "\n" |
| /* Odd invocations should read values stored by preceding even invocation, |
| * add current invocation's ID to that value, and then write it to its per-vertex |
| * output. |
| */ |
| " if ((gl_InvocationID % 2) == 1)\n" |
| " {\n" |
| " tcs_data[gl_InvocationID] = tcs_data[gl_InvocationID - 1] + gl_InvocationID;\n" |
| " }\n" |
| "\n" |
| " barrier();\n" |
| "\n" |
| /* Every fourth invocation should now read & sum up per-vertex outputs for four invocations |
| * following it (including the one discussed), and store it in a per-patch variable */ |
| " tcs_patch_result[gl_InvocationID] = 0;\n" |
| "\n" |
| " if ((gl_InvocationID % 4) == 0)\n" |
| " {\n" |
| " tcs_patch_result[gl_InvocationID] += tcs_data[gl_InvocationID];\n" |
| " tcs_patch_result[gl_InvocationID] += tcs_data[gl_InvocationID+1];\n" |
| " tcs_patch_result[gl_InvocationID] += tcs_data[gl_InvocationID+2];\n" |
| " tcs_patch_result[gl_InvocationID] += tcs_data[gl_InvocationID+3];\n" |
| " }\n" |
| "\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| "}\n"; |
| |
| return tcs_code; |
| } |
| |
| /** Retrieves tessellation evaluation shader body. |
| * |
| * @return TC stage shader body. |
| **/ |
| const char* TessellationShaderBarrier3::getTESCode() |
| { |
| static const char* tes_code = "${VERSION}\n" |
| "\n" |
| "${TESSELLATION_SHADER_REQUIRE}\n" |
| "\n" |
| "layout(isolines, point_mode) in;\n" |
| "\n" |
| "patch in int tcs_patch_result[16];\n" |
| "\n" |
| "flat out ivec4 tes_result1;\n" |
| "flat out ivec4 tes_result2;\n" |
| "flat out ivec4 tes_result3;\n" |
| "flat out ivec4 tes_result4;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " tes_result1 = ivec4(tcs_patch_result[0], tcs_patch_result[1], " |
| "tcs_patch_result[2], tcs_patch_result[3]);\n" |
| " tes_result2 = ivec4(tcs_patch_result[4], tcs_patch_result[5], " |
| "tcs_patch_result[6], tcs_patch_result[7]);\n" |
| " tes_result3 = ivec4(tcs_patch_result[8], tcs_patch_result[9], " |
| "tcs_patch_result[10], tcs_patch_result[11]);\n" |
| " tes_result4 = ivec4(tcs_patch_result[12], tcs_patch_result[13], " |
| "tcs_patch_result[14], tcs_patch_result[15]);\n" |
| "}\n"; |
| |
| return tes_code; |
| } |
| |
| /** Retrieves vertex shader body. |
| * |
| * @return Vertex shader body. |
| **/ |
| const char* TessellationShaderBarrier3::getVSCode() |
| { |
| static const char* vs_code = "${VERSION}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n"; |
| |
| return vs_code; |
| } |
| |
| /** Retrieves amount of bytes that should be used for allocating storage space for |
| * a buffer object that will later be used to hold XFB result data. |
| * |
| * @return Amount of bytes required by the test. |
| */ |
| int TessellationShaderBarrier3::getXFBBufferSize() |
| { |
| return static_cast<int>(m_n_instances * m_n_result_vertices * sizeof(int) * 4 /* ivec4 */ * |
| 2 /* points per isoline */); |
| } |
| |
| /** Retrieves names of transform feedback varyings and amount of those. These should be used |
| * prior to link the test program object. |
| * |
| * @param out_n_names Deref will be used to store the number of names that @param out_names array |
| * holds. Must not be NULL. |
| * @param out_names Deref will be used to store a pointer to an array holding TF varying names; |
| * Must not be NULL. |
| **/ |
| void TessellationShaderBarrier3::getXFBProperties(int* out_n_names, const char*** out_names) |
| { |
| static const char* names[] = { "tes_result1", "tes_result2", "tes_result3", "tes_result4" }; |
| |
| *out_n_names = 4; |
| *out_names = names; |
| } |
| |
| /** Verifies data captured by XFB is correct. |
| * |
| * @param data Buffer holding the result XFB data. Must not be NULL. |
| * |
| * @return true if the result data is confirmed to be valid, false otherwise. |
| **/ |
| bool TessellationShaderBarrier3::verifyXFBBuffer(const void* data) |
| { |
| const int* data_int = (const int*)data; |
| std::vector<int> tcs_data(m_n_invocations, 0); |
| std::vector<int> tcs_patch_result(m_n_invocations, 0); |
| |
| /* This is a simple C++ port of the TCS used for the test. |
| * |
| * Note: We only need to consider a single set of values stored by TES |
| * for a single result point, as the same set of values will be |
| * reported for the other point. Owing to the fact gl_InvocationID |
| * in TCS will iterate from 0 to 15 for all input patches and instances, |
| * we can re-use the data for all subsequent input patches. */ |
| /* Phase 1 */ |
| for (unsigned int n = 0; n < m_n_invocations; n += 2) |
| { |
| tcs_data[n] = n; |
| } |
| |
| /* Phase 2 */ |
| for (unsigned int n = 1; n < m_n_invocations; n += 2) |
| { |
| tcs_data[n] = tcs_data[n - 1] + n; |
| } |
| |
| /* Phase 3 */ |
| for (unsigned int n_patch_vertex = 0; n_patch_vertex < m_n_invocations; ++n_patch_vertex) |
| { |
| const unsigned int invocation_id = n_patch_vertex; |
| |
| tcs_patch_result[invocation_id] = 0; |
| |
| if ((invocation_id % 4) == 0) |
| { |
| tcs_patch_result[invocation_id] += tcs_data[invocation_id]; |
| tcs_patch_result[invocation_id] += tcs_data[invocation_id + 1]; |
| tcs_patch_result[invocation_id] += tcs_data[invocation_id + 2]; |
| tcs_patch_result[invocation_id] += tcs_data[invocation_id + 3]; |
| } |
| } /* for (all patch vertices) */ |
| |
| /* Time to do the actual comparison. */ |
| for (unsigned int n_patch = 0; n_patch < m_n_result_vertices / m_n_invocations; ++n_patch) |
| { |
| bool are_equal = true; |
| const int n_points_per_line_segment = 2; |
| const int* patch_data_int = data_int + n_patch * m_n_invocations * n_points_per_line_segment; |
| |
| for (unsigned int n_invocation = 0; n_invocation < m_n_invocations; ++n_invocation) |
| { |
| if (patch_data_int[n_invocation] != tcs_patch_result[n_invocation]) |
| { |
| are_equal = false; |
| |
| break; |
| } |
| } /* for (all patch vertices which have contributed for given input patch being considered) */ |
| |
| if (!are_equal) |
| { |
| std::stringstream logMessage; |
| |
| logMessage << "Result data for patch [" << n_patch << "]: ("; |
| |
| for (unsigned int n_patch_vertex = 0; n_patch_vertex < m_n_patch_vertices; ++n_patch_vertex) |
| { |
| logMessage << patch_data_int[n_patch_vertex]; |
| |
| if (n_patch_vertex == (m_n_patch_vertices - 1)) |
| { |
| logMessage << "), "; |
| } |
| else |
| { |
| logMessage << ", "; |
| } |
| } /* for (all patch vertices) */ |
| |
| logMessage << "expected: "; |
| |
| for (unsigned int n_patch_vertex = 0; n_patch_vertex < m_n_patch_vertices; ++n_patch_vertex) |
| { |
| logMessage << tcs_patch_result[n_patch_vertex]; |
| |
| if (n_patch_vertex == (m_n_patch_vertices - 1)) |
| { |
| logMessage << "). "; |
| } |
| else |
| { |
| logMessage << ", "; |
| } |
| } /* for (all patch vertices) */ |
| |
| /* Log the message */ |
| m_testCtx.getLog() << tcu::TestLog::Message << logMessage.str().c_str() << tcu::TestLog::EndMessage; |
| |
| /* Bail out */ |
| TCU_FAIL("Invalid data captured"); |
| } /* if (!are_equal) */ |
| } /* for (all patches) */ |
| |
| return true; |
| } |
| |
| } /* namespace glcts */ |
