| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2015-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 "gl4cStencilTexturingTests.hpp" |
| |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| #include <algorithm> |
| #include <string> |
| #include <vector> |
| |
| #define DEBUG_REPLACE_TOKEN 0 |
| |
| using namespace glw; |
| |
| namespace gl4cts |
| { |
| namespace StencilTexturing |
| { |
| class Utils |
| { |
| public: |
| static GLuint createAndBuildProgram(deqp::Context& context, const GLchar* cs_code, const GLchar* fs_code, |
| const GLchar* gs_code, const GLchar* tcs_code, const GLchar* tes_code, |
| const GLchar* vs_code); |
| |
| static GLuint createAndCompileShader(deqp::Context& context, const GLenum type, const GLchar* code); |
| |
| static GLuint createAndFill2DTexture(deqp::Context& context, GLuint width, GLuint height, GLenum internal_format, |
| GLenum format, GLenum type, const GLvoid* data); |
| |
| static void deleteProgram(deqp::Context& context, const GLuint id); |
| static void deleteShader(deqp::Context& context, const GLuint id); |
| static void deleteTexture(deqp::Context& context, const GLuint id); |
| static bool isExtensionSupported(deqp::Context& context, const GLchar* extension_name); |
| |
| static void replaceToken(const GLchar* token, size_t& search_position, const GLchar* text, std::string& string); |
| }; |
| |
| /** Create and build program from provided sources |
| * |
| * @param context Test context |
| * @param cs_code Source code for compute shader stage |
| * @param fs_code Source code for fragment shader stage |
| * @param gs_code Source code for geometry shader stage |
| * @param tcs_code Source code for tesselation control shader stage |
| * @param tes_code Source code for tesselation evaluation shader stage |
| * @param vs_code Source code for vertex shader stage |
| * |
| * @return ID of program object |
| **/ |
| GLuint Utils::createAndBuildProgram(deqp::Context& context, const GLchar* cs_code, const GLchar* fs_code, |
| const GLchar* gs_code, const GLchar* tcs_code, const GLchar* tes_code, |
| const GLchar* vs_code) |
| { |
| #define N_SHADER_STAGES 6 |
| |
| const Functions& gl = context.getRenderContext().getFunctions(); |
| GLuint id = 0; |
| GLuint shader_ids[N_SHADER_STAGES] = { 0 }; |
| |
| const GLchar* shader_sources[N_SHADER_STAGES] = { cs_code, fs_code, gs_code, tcs_code, tes_code, vs_code }; |
| |
| const GLenum shader_types[N_SHADER_STAGES] = { GL_COMPUTE_SHADER, GL_FRAGMENT_SHADER, |
| GL_GEOMETRY_SHADER, GL_TESS_CONTROL_SHADER, |
| GL_TESS_EVALUATION_SHADER, GL_VERTEX_SHADER }; |
| GLint status = GL_FALSE; |
| |
| /* Compile all shaders */ |
| try |
| { |
| for (GLuint i = 0; i < N_SHADER_STAGES; ++i) |
| { |
| if (0 != shader_sources[i]) |
| { |
| shader_ids[i] = createAndCompileShader(context, shader_types[i], shader_sources[i]); |
| } |
| } |
| |
| /* Check compilation */ |
| for (GLuint i = 0; i < N_SHADER_STAGES; ++i) |
| { |
| if ((0 != shader_sources[i]) && (0 == shader_ids[i])) |
| { |
| context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Failed to build program due to compilation problems" |
| << tcu::TestLog::EndMessage; |
| |
| /* Delete shaders */ |
| for (GLuint j = 0; j < N_SHADER_STAGES; ++j) |
| { |
| deleteShader(context, shader_ids[j]); |
| } |
| |
| /* Done */ |
| return 0; |
| } |
| } |
| |
| /* Create program */ |
| id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); |
| |
| /* Attach shaders */ |
| for (GLuint i = 0; i < N_SHADER_STAGES; ++i) |
| { |
| if (0 != shader_ids[i]) |
| { |
| gl.attachShader(id, shader_ids[i]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| } |
| |
| /* Link program */ |
| gl.linkProgram(id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram"); |
| |
| /* Clean shaders */ |
| for (GLuint j = 0; j < N_SHADER_STAGES; ++j) |
| { |
| deleteShader(context, shader_ids[j]); |
| } |
| |
| /* Get link status */ |
| gl.getProgramiv(id, GL_LINK_STATUS, &status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| /* Log link error */ |
| if (GL_TRUE != status) |
| { |
| glw::GLint length = 0; |
| std::string message; |
| |
| /* Get error log length */ |
| gl.getProgramiv(id, GL_INFO_LOG_LENGTH, &length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| message.resize(length, 0); |
| |
| /* Get error log */ |
| gl.getProgramInfoLog(id, length, 0, &message[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); |
| |
| context.getTestContext().getLog() << tcu::TestLog::Message << "Program linking failed: " << message |
| << tcu::TestLog::EndMessage; |
| |
| /* Clean program */ |
| deleteProgram(context, id); |
| |
| /* Done */ |
| return 0; |
| } |
| } |
| catch (std::exception& exc) |
| { |
| /* Delete shaders */ |
| for (GLuint j = 0; j < N_SHADER_STAGES; ++j) |
| { |
| deleteShader(context, shader_ids[j]); |
| } |
| |
| throw exc; |
| } |
| |
| return id; |
| } |
| |
| /** Create and compile shader |
| * |
| * @param context Test context |
| * @param type Type of shader |
| * @param code Source code for shader |
| * |
| * @return ID of shader object |
| **/ |
| GLuint Utils::createAndCompileShader(deqp::Context& context, const GLenum type, const GLchar* code) |
| { |
| const Functions& gl = context.getRenderContext().getFunctions(); |
| GLuint id = gl.createShader(type); |
| GLint status = GL_FALSE; |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| try |
| { |
| gl.shaderSource(id, 1 /* count */, &code, 0 /* lengths */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource"); |
| |
| /* Compile */ |
| gl.compileShader(id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader"); |
| |
| /* Get compilation status */ |
| gl.getShaderiv(id, GL_COMPILE_STATUS, &status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); |
| |
| /* Log compilation error */ |
| if (GL_TRUE != status) |
| { |
| glw::GLint length = 0; |
| std::string message; |
| |
| /* Error log length */ |
| gl.getShaderiv(id, GL_INFO_LOG_LENGTH, &length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); |
| |
| /* Prepare storage */ |
| message.resize(length, 0); |
| |
| /* Get error log */ |
| gl.getShaderInfoLog(id, length, 0, &message[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog"); |
| |
| context.getTestContext().getLog() << tcu::TestLog::Message << "Shader (" << glu::getShaderTypeStr(type) |
| << ") compilation failed: " << message << tcu::TestLog::EndMessage; |
| |
| deleteShader(context, id); |
| id = 0; |
| } |
| } |
| catch (std::exception& exc) |
| { |
| deleteShader(context, id); |
| throw exc; |
| } |
| |
| return id; |
| } |
| |
| /** Generate and fill 2d texture |
| * |
| * @param context Test context |
| * @param width Width of texture |
| * @param height Height of texture |
| * @param internal_format Internal format of texture |
| * @param format Format of data |
| * @param type Type of data |
| * @param data Data |
| * |
| * @return ID of texture object |
| **/ |
| GLuint Utils::createAndFill2DTexture(deqp::Context& context, GLuint width, GLuint height, GLenum internal_format, |
| GLenum format, GLenum type, const GLvoid* data) |
| { |
| const Functions& gl = context.getRenderContext().getFunctions(); |
| GLuint id = 0; |
| |
| gl.genTextures(1, &id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); |
| |
| try |
| { |
| gl.bindTexture(GL_TEXTURE_2D, id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| gl.texImage2D(GL_TEXTURE_2D, 0 /* level */, internal_format, width, height, 0 /* border */, format, type, data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexImage2D"); |
| |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri"); |
| |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| } |
| catch (std::exception& exc) |
| { |
| gl.deleteTextures(1, &id); |
| id = 0; |
| |
| throw exc; |
| } |
| |
| return id; |
| } |
| |
| /** Delete program |
| * |
| * @param context Test context |
| * @param id ID of program |
| **/ |
| void Utils::deleteProgram(deqp::Context& context, const GLuint id) |
| { |
| const glw::Functions& gl = context.getRenderContext().getFunctions(); |
| |
| if (0 != id) |
| { |
| gl.deleteProgram(id); |
| } |
| } |
| |
| /** Delete shader |
| * |
| * @param context Test context |
| * @param id ID of shader |
| **/ |
| void Utils::deleteShader(deqp::Context& context, const GLuint id) |
| { |
| const glw::Functions& gl = context.getRenderContext().getFunctions(); |
| |
| if (0 != id) |
| { |
| gl.deleteShader(id); |
| } |
| } |
| |
| /** Delete texture |
| * |
| * @param context Test context |
| * @param id ID of texture |
| **/ |
| void Utils::deleteTexture(deqp::Context& context, const GLuint id) |
| { |
| const glw::Functions& gl = context.getRenderContext().getFunctions(); |
| |
| if (0 != id) |
| { |
| gl.deleteTextures(1, &id); |
| } |
| } |
| |
| /** Checks if extensions is not available. |
| * |
| * @param context Test context |
| * @param extension_name Name of extension |
| * |
| * @return true if extension is reported as available, false otherwise |
| **/ |
| bool Utils::isExtensionSupported(deqp::Context& context, const GLchar* extension_name) |
| { |
| const std::vector<std::string>& extensions = context.getContextInfo().getExtensions(); |
| |
| if (std::find(extensions.begin(), extensions.end(), extension_name) == extensions.end()) |
| { |
| std::string message = "Required extension is not supported: "; |
| message.append(extension_name); |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Replace first occurance of <token> with <text> in <string> starting at <search_posistion> |
| * |
| * @param token Token string |
| * @param search_position Position at which find will start, it is updated to position at which replaced text ends |
| * @param text String that will be used as replacement for <token> |
| * @param string String to work on |
| **/ |
| void Utils::replaceToken(const GLchar* token, size_t& search_position, const GLchar* text, std::string& string) |
| { |
| const size_t text_length = strlen(text); |
| const size_t token_length = strlen(token); |
| const size_t token_position = string.find(token, search_position); |
| |
| #if DEBUG_REPLACE_TOKEN |
| if (std::string::npos == token_position) |
| { |
| string.append("\n\nInvalid token: "); |
| string.append(token); |
| |
| TCU_FAIL(string.c_str()); |
| } |
| #endif /* DEBUG_REPLACE_TOKEN */ |
| |
| string.replace(token_position, token_length, text, text_length); |
| |
| search_position = token_position + text_length; |
| } |
| |
| /* FunctionalTest */ |
| /* Shader sources */ |
| const GLchar* FunctionalTest::m_compute_shader_code = |
| "#version 430 core\n" |
| "\n" |
| "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" |
| "\n" |
| "IMAGE_DEFINITION;\n" |
| "SAMPLER_DEFINITION;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec2 tex_coord = vec2(gl_GlobalInvocationID.xy) / 8.0;\n" |
| "\n" |
| " imageStore(uni_image,\n" |
| " ivec2(gl_GlobalInvocationID.xy),\n" |
| " TYPE(texture(uni_sampler, tex_coord).r, 0, 0, 0));\n" |
| "}\n" |
| "\n"; |
| |
| const GLchar* FunctionalTest::m_fragment_shader_code = |
| "#version 430 core\n" |
| "\n" |
| " in vec2 gs_fs_tex_coord;\n" |
| "flat in uint gs_fs_result;\n" |
| " out TYPE fs_out_result;\n" |
| "\n" |
| "SAMPLER_DEFINITION;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " if (1 != gs_fs_result)\n" |
| " {\n" |
| " fs_out_result = texture(uni_sampler, vec2(0.9375, 0.9375));\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " fs_out_result = texture(uni_sampler, gs_fs_tex_coord);\n" |
| " }\n" |
| "}\n" |
| "\n"; |
| |
| const GLchar* FunctionalTest::m_geometry_shader_code = |
| "#version 430 core\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| " in uint tes_gs_result[];\n" |
| "flat out uint gs_fs_result;\n" |
| " out vec2 gs_fs_tex_coord;\n" |
| "\n" |
| "SAMPLER_DEFINITION;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint result = 1u;\n" |
| "\n" |
| " if (1 != tes_gs_result[0])\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " if (EXPECTED_VALUE != texture(uni_sampler, vec2(0.9375, 0.9375)).r)\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " gs_fs_result = result;\n" |
| " gs_fs_tex_coord = vec2(0, 0);\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " gs_fs_result = result;\n" |
| " gs_fs_tex_coord = vec2(0, 1);\n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " gs_fs_result = result;\n" |
| " gs_fs_tex_coord = vec2(1, 0);\n" |
| " gl_Position = vec4(1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " gs_fs_result = result;\n" |
| " gs_fs_tex_coord = vec2(1, 1);\n" |
| " gl_Position = vec4(1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| "}\n" |
| "\n"; |
| |
| const GLchar* FunctionalTest::m_tesselation_control_shader_code = |
| "#version 430 core\n" |
| "\n" |
| "layout(vertices = 1) out;\n" |
| "\n" |
| "in uint vs_tcs_result[];\n" |
| "out uint tcs_tes_result[];\n" |
| "\n" |
| "SAMPLER_DEFINITION;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint result = 1u;\n" |
| "\n" |
| " if (1u != vs_tcs_result[gl_InvocationID])\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " if (EXPECTED_VALUE != texture(uni_sampler, vec2(0.9375, 0.9375)).r)\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " tcs_tes_result[gl_InvocationID] = result;\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" |
| "\n"; |
| |
| const GLchar* FunctionalTest::m_tesselation_evaluation_shader_code = |
| "#version 430 core\n" |
| "\n" |
| "layout(isolines, point_mode) in;\n" |
| "\n" |
| "in uint tcs_tes_result[];\n" |
| "out uint tes_gs_result;\n" |
| "\n" |
| "SAMPLER_DEFINITION;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint result = 1u;\n" |
| "\n" |
| " if (1u != tcs_tes_result[0])\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " if (EXPECTED_VALUE != texture(uni_sampler, vec2(0.9375, 0.9375)).r)\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " tes_gs_result = result;\n" |
| "}\n" |
| "\n"; |
| |
| const GLchar* FunctionalTest::m_vertex_shader_code = |
| "#version 430 core\n" |
| "\n" |
| "out uint vs_tcs_result;\n" |
| "\n" |
| "SAMPLER_DEFINITION;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " uint result = 1u;\n" |
| "\n" |
| " if (EXPECTED_VALUE != texture(uni_sampler, vec2(0.9375, 0.9375)).r)\n" |
| " {\n" |
| " result = 0u;\n" |
| " }\n" |
| "\n" |
| " vs_tcs_result = result;\n" |
| "}\n" |
| "\n"; |
| |
| const GLchar* FunctionalTest::m_expected_value_depth = "0.0"; |
| |
| const GLchar* FunctionalTest::m_expected_value_stencil = "15u"; |
| |
| const GLchar* FunctionalTest::m_image_definition_depth = "writeonly uniform image2D uni_image"; |
| |
| const GLchar* FunctionalTest::m_image_definition_stencil = "writeonly uniform uimage2D uni_image"; |
| |
| const GLchar* FunctionalTest::m_output_type_depth = "vec4"; |
| |
| const GLchar* FunctionalTest::m_output_type_stencil = "uvec4"; |
| |
| const GLchar* FunctionalTest::m_sampler_definition_depth = "uniform sampler2D uni_sampler"; |
| |
| const GLchar* FunctionalTest::m_sampler_definition_stencil = "uniform usampler2D uni_sampler"; |
| |
| /* Constants */ |
| const GLuint FunctionalTest::m_height = 8; |
| const GLint FunctionalTest::m_image_unit = 1; |
| const GLint FunctionalTest::m_texture_unit = 1; |
| const GLuint FunctionalTest::m_width = 8; |
| |
| /** Constructor |
| * |
| * @param context Test context |
| **/ |
| FunctionalTest::FunctionalTest(deqp::Context& context) |
| : TestCase(context, "functional", "Checks if sampling stencil texture gives expected results") |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest::iterate() |
| { |
| bool test_result = true; |
| |
| if (false == test(GL_DEPTH24_STENCIL8, true)) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Test failed. Case format: GL_DEPTH24_STENCIL8, channel: S" |
| << tcu::TestLog::EndMessage; |
| test_result = false; |
| } |
| |
| if (false == test(GL_DEPTH24_STENCIL8, false)) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Test failed. Case format: GL_DEPTH24_STENCIL8, channel: D" |
| << tcu::TestLog::EndMessage; |
| test_result = false; |
| } |
| |
| if (false == test(GL_DEPTH32F_STENCIL8, true)) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Test failed. Case format: GL_DEPTH32F_STENCIL8, channel: S" |
| << tcu::TestLog::EndMessage; |
| test_result = false; |
| } |
| |
| if (false == test(GL_DEPTH32F_STENCIL8, false)) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Test failed. Case format: GL_DEPTH32F_STENCIL8, channel: D" |
| << tcu::TestLog::EndMessage; |
| test_result = false; |
| } |
| |
| /* Set result */ |
| if (true == test_result) |
| { |
| m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Execute compute program |
| * |
| * @param program_id ID of program |
| * @param is_stencil Selects if stencil or depth channel is sampled |
| * @param dst_texture_id ID of destination texture |
| * @param src_texture_id ID of source texture |
| **/ |
| void FunctionalTest::dispatch(GLuint program_id, bool is_stencil, GLuint dst_texture_id, GLuint src_texture_id) |
| { |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLenum internal_format = GL_R8UI; |
| GLint uni_image_loc = -1; |
| GLint uni_sampler_loc = -1; |
| |
| if (false == is_stencil) |
| { |
| internal_format = GL_R32F; |
| } |
| |
| /* Set program */ |
| gl.useProgram(program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); |
| |
| /* Get uniform location and bind texture to proper image unit */ |
| uni_image_loc = gl.getUniformLocation(program_id, "uni_image"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); |
| |
| gl.bindImageTexture(m_image_unit, dst_texture_id, 0 /* level */, GL_FALSE /* layered */, 0 /* Layer */, |
| GL_WRITE_ONLY, internal_format); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); |
| |
| gl.uniform1i(uni_image_loc, m_image_unit); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); |
| |
| /* Get uniform location and bind texture to proper texture unit */ |
| uni_sampler_loc = gl.getUniformLocation(program_id, "uni_sampler"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); |
| |
| gl.activeTexture(GL_TEXTURE0 + m_texture_unit); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); |
| |
| gl.bindTexture(GL_TEXTURE_2D, src_texture_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| gl.uniform1i(uni_sampler_loc, m_texture_unit); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); |
| |
| /* Dispatch program */ |
| gl.dispatchCompute(m_width, m_height, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DispatchCompute"); |
| |
| /* Sync */ |
| gl.memoryBarrier(GL_ALL_BARRIER_BITS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier"); |
| } |
| |
| /** Execute draw program |
| * |
| * @param program_id ID of program |
| * @param dst_texture_id ID of destination texture |
| * @param src_texture_id ID of source texture |
| **/ |
| void FunctionalTest::draw(GLuint program_id, GLuint dst_texture_id, GLuint src_texture_id) |
| { |
| GLuint fb_id = 0; |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint uni_sampler_loc = -1; |
| GLuint vao_id = 0; |
| |
| try |
| { |
| /* Tesselation patch set up */ |
| gl.patchParameteri(GL_PATCH_VERTICES, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); |
| |
| /* Prepare VAO */ |
| gl.genVertexArrays(1, &vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); |
| |
| gl.bindVertexArray(vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); |
| |
| /* Prepare FBO */ |
| gl.genFramebuffers(1, &fb_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers"); |
| |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, fb_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer"); |
| |
| gl.framebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dst_texture_id, 0 /* level */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture"); |
| |
| gl.viewport(0 /* x */, 0 /* y */, m_width, m_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Viewport"); |
| |
| /* Set program */ |
| gl.useProgram(program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); |
| |
| /* Get uniform location and bind texture to proper texture unit */ |
| uni_sampler_loc = gl.getUniformLocation(program_id, "uni_sampler"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); |
| |
| gl.activeTexture(GL_TEXTURE0 + m_texture_unit); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); |
| |
| gl.bindTexture(GL_TEXTURE_2D, src_texture_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| gl.uniform1i(uni_sampler_loc, m_texture_unit); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); |
| |
| /* Draw */ |
| gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| /* Sync */ |
| gl.memoryBarrier(GL_ALL_BARRIER_BITS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier"); |
| } |
| catch (std::exception& exc) |
| { |
| gl.bindVertexArray(0); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| |
| if (0 != vao_id) |
| { |
| gl.deleteVertexArrays(1, &vao_id); |
| } |
| |
| if (0 != fb_id) |
| { |
| gl.deleteFramebuffers(1, &fb_id); |
| } |
| |
| throw exc; |
| } |
| |
| gl.bindVertexArray(0); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| |
| if (0 != vao_id) |
| { |
| gl.deleteVertexArrays(1, &vao_id); |
| } |
| |
| if (0 != fb_id) |
| { |
| gl.deleteFramebuffers(1, &fb_id); |
| } |
| } |
| |
| /** Prepare destination texture |
| * |
| * @param is_stencil Selects if stencil or depth channel is sampled |
| * |
| * @return ID of texture |
| **/ |
| GLuint FunctionalTest::prepareDestinationTexture(bool is_stencil) |
| { |
| static const GLuint n_pixels = m_width * m_height; |
| GLenum format = 0; |
| GLenum internal_format = 0; |
| GLuint pixel_size = 0; |
| std::vector<GLubyte> texture_data; |
| GLuint texture_id = 0; |
| GLuint texture_size = 0; |
| GLenum type = 0; |
| |
| /* Select size of pixel */ |
| if (true == is_stencil) |
| { |
| format = GL_RED_INTEGER; |
| internal_format = GL_R8UI; |
| pixel_size = 1; |
| type = GL_UNSIGNED_BYTE; |
| } |
| else |
| { |
| format = GL_RED; |
| internal_format = GL_R32F; |
| pixel_size = 4; |
| type = GL_FLOAT; |
| } |
| |
| /* Allocate storage */ |
| texture_size = pixel_size * n_pixels; |
| texture_data.resize(texture_size); |
| |
| /* Fill texture data */ |
| memset(&texture_data[0], 0, texture_size); |
| |
| /* Create texture */ |
| texture_id = |
| Utils::createAndFill2DTexture(m_context, m_width, m_height, internal_format, format, type, &texture_data[0]); |
| |
| /* Done */ |
| return texture_id; |
| } |
| |
| /** Prepare program |
| * |
| * @param is_draw Selects if draw or compute program is prepared |
| * @param is_stencil Selects if stencil or depth channel is sampled |
| * |
| * @return ID of texture |
| **/ |
| GLuint FunctionalTest::prepareProgram(bool is_draw, bool is_stencil) |
| { |
| GLuint program_id = 0; |
| |
| if (true != is_draw) |
| { |
| std::string cs_code = m_compute_shader_code; |
| const GLchar* image_definition = m_image_definition_stencil; |
| size_t position = 0; |
| const GLchar* sampler_definition = m_sampler_definition_stencil; |
| const GLchar* type = m_output_type_stencil; |
| |
| if (false == is_stencil) |
| { |
| image_definition = m_image_definition_depth; |
| sampler_definition = m_sampler_definition_depth; |
| type = m_output_type_depth; |
| } |
| |
| Utils::replaceToken("IMAGE_DEFINITION", position, image_definition, cs_code); |
| Utils::replaceToken("SAMPLER_DEFINITION", position, sampler_definition, cs_code); |
| Utils::replaceToken("TYPE", position, type, cs_code); |
| |
| program_id = Utils::createAndBuildProgram(m_context, cs_code.c_str(), 0 /* fs_code */, 0 /* gs_code */, |
| 0 /* tcs_code */, 0 /* tes_code */, 0 /* vs_code */); |
| } |
| else |
| { |
| #define N_FUNCTIONAL_TEST_SHADER_STAGES 5 |
| |
| const GLchar* expected_value = m_expected_value_stencil; |
| const GLchar* sampler_definition = m_sampler_definition_stencil; |
| std::string shader_code[N_FUNCTIONAL_TEST_SHADER_STAGES]; |
| const GLchar* shader_templates[N_FUNCTIONAL_TEST_SHADER_STAGES] = { |
| m_fragment_shader_code, m_geometry_shader_code, m_tesselation_control_shader_code, |
| m_tesselation_evaluation_shader_code, m_vertex_shader_code |
| }; |
| const GLchar* type = m_output_type_stencil; |
| |
| if (false == is_stencil) |
| { |
| expected_value = m_expected_value_depth; |
| sampler_definition = m_sampler_definition_depth; |
| type = m_output_type_depth; |
| } |
| |
| for (GLuint i = 0; i < N_FUNCTIONAL_TEST_SHADER_STAGES; ++i) |
| { |
| size_t position = 0; |
| |
| shader_code[i] = shader_templates[i]; |
| |
| if (0 == i) |
| { |
| Utils::replaceToken("TYPE", position, type, shader_code[i]); |
| Utils::replaceToken("SAMPLER_DEFINITION", position, sampler_definition, shader_code[i]); |
| //Utils::replaceToken("TYPE", position, type, shader_code[i]); |
| } |
| else |
| { |
| Utils::replaceToken("SAMPLER_DEFINITION", position, sampler_definition, shader_code[i]); |
| Utils::replaceToken("EXPECTED_VALUE", position, expected_value, shader_code[i]); |
| } |
| } |
| |
| program_id = |
| Utils::createAndBuildProgram(m_context, 0 /* cs_code */, shader_code[0].c_str() /* fs_code */, |
| shader_code[1].c_str() /* gs_code */, shader_code[2].c_str() /* tcs_code */, |
| shader_code[3].c_str() /* tes_code */, shader_code[4].c_str() /* vs_code */); |
| } |
| |
| /* Done */ |
| return program_id; |
| } |
| |
| /** Prepare source texture |
| * |
| * @param internal_format Internal format of texture |
| * @param is_stencil Selects if stencil or depth channel is sampled |
| * @param texture_data Texture contents |
| * |
| * @return ID of texture |
| **/ |
| GLuint FunctionalTest::prepareSourceTexture(GLenum internal_format, bool is_stencil, |
| const std::vector<glw::GLubyte>& texture_data) |
| { |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint texture_id = 0; |
| GLenum type = 0; |
| |
| /* Select size of pixel */ |
| switch (internal_format) |
| { |
| case GL_DEPTH24_STENCIL8: |
| type = GL_UNSIGNED_INT_24_8; |
| break; |
| case GL_DEPTH32F_STENCIL8: |
| type = GL_FLOAT_32_UNSIGNED_INT_24_8_REV; |
| break; |
| default: |
| TCU_FAIL("Invalid enum"); |
| } |
| |
| /* Create texture */ |
| texture_id = Utils::createAndFill2DTexture(m_context, m_width, m_height, internal_format, GL_DEPTH_STENCIL, type, |
| &texture_data[0]); |
| |
| /* Set DS texture mode */ |
| gl.bindTexture(GL_TEXTURE_2D, texture_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| if (true == is_stencil) |
| { |
| gl.texParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri"); |
| } |
| else |
| { |
| gl.texParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_DEPTH_COMPONENT); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri"); |
| } |
| |
| /* Set nearest filtering */ |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri"); |
| |
| /* Unbind */ |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| /* Done */ |
| return texture_id; |
| } |
| |
| /** Prepare data for source texture |
| * |
| * @param internal_format Internal format of texture |
| * @param texture_data Texture contents |
| * |
| * @return ID of texture |
| **/ |
| void FunctionalTest::prepareSourceTextureData(GLenum internal_format, std::vector<GLubyte>& texture_data) |
| { |
| static const GLfloat depth_step_h = -0.5f / ((GLfloat)(m_width - 1)); |
| static const GLfloat depth_step_v = -0.5f / ((GLfloat)(m_height - 1)); |
| static const GLuint stencil_step_h = 1; |
| static const GLuint stencil_step_v = 1; |
| static const GLuint n_pixels = m_width * m_height; |
| GLuint pixel_size = 0; |
| GLuint line_size = 0; |
| GLuint texture_size = 0; |
| |
| /* Select size of pixel */ |
| switch (internal_format) |
| { |
| case GL_DEPTH24_STENCIL8: |
| pixel_size = 4; |
| break; |
| case GL_DEPTH32F_STENCIL8: |
| pixel_size = 8; |
| break; |
| default: |
| TCU_FAIL("Invalid enum"); |
| } |
| |
| line_size = pixel_size * m_width; |
| texture_size = pixel_size * n_pixels; |
| |
| /* Allocate storage */ |
| texture_data.resize(texture_size); |
| |
| /* Fill texture data */ |
| for (GLuint y = 0; y < m_height; ++y) |
| { |
| const GLfloat depth_v = depth_step_v * (GLfloat)y; |
| const GLuint line_offset = line_size * y; |
| const GLuint stencil_v = stencil_step_v * y; |
| |
| for (GLuint x = 0; x < m_width; ++x) |
| { |
| const GLfloat depth_h = depth_step_h * (GLfloat)x; |
| const GLfloat depth_f = 1 + depth_h + depth_v; |
| const GLuint depth_i = (GLuint)(((GLfloat)0xffffff) * depth_f); |
| const GLuint pixel_offset = pixel_size * x; |
| const GLuint stencil_h = stencil_step_h * x; |
| const GLuint stencil = 1 + stencil_h + stencil_v; |
| |
| GLubyte* depth_f_data = (GLubyte*)&depth_f; |
| GLubyte* depth_i_data = (GLubyte*)&depth_i; |
| GLubyte* pixel_data = &texture_data[0] + line_offset + pixel_offset; |
| GLubyte* stencil_data = (GLubyte*)&stencil; |
| |
| switch (pixel_size) |
| { |
| case 4: |
| memcpy(pixel_data, stencil_data, 1); |
| memcpy(pixel_data + 1, depth_i_data, 3); |
| break; |
| case 8: |
| memcpy(pixel_data, depth_f_data, 4); |
| memcpy(pixel_data + 4, stencil_data, 1); |
| break; |
| default: |
| TCU_FAIL("Invalid value"); |
| } |
| } |
| } |
| } |
| |
| /** Verifies that destination texture contents match expectations |
| * |
| * @param id ID of destination texture |
| * @param source_internal_format Internal format of source texture |
| * @param is_stencil Selects if stencil of depth channel is sampled |
| * @param src_texture_data Contents of source texture |
| * |
| * @return true if everything is fine, false otherwise |
| **/ |
| bool FunctionalTest::verifyTexture(GLuint id, GLenum source_internal_format, bool is_stencil, |
| const std::vector<GLubyte>& src_texture_data) |
| { |
| static const GLuint n_pixels = m_width * m_height; |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint dst_pixel_size = 0; |
| std::vector<GLubyte> dst_texture_data; |
| GLuint dst_texture_size = 0; |
| GLenum format = 0; |
| GLuint src_pixel_size = 0; |
| GLuint src_stencil_off = 0; |
| GLenum type = 0; |
| |
| /* Select size of pixel */ |
| if (true == is_stencil) |
| { |
| format = GL_RED_INTEGER; |
| dst_pixel_size = 1; |
| type = GL_UNSIGNED_BYTE; |
| } |
| else |
| { |
| format = GL_RED; |
| dst_pixel_size = 4; |
| type = GL_FLOAT; |
| } |
| |
| if (GL_DEPTH24_STENCIL8 == source_internal_format) |
| { |
| src_pixel_size = 4; |
| } |
| else |
| { |
| src_pixel_size = 8; |
| src_stencil_off = 4; |
| } |
| |
| /* Allocate storage */ |
| dst_texture_size = dst_pixel_size * n_pixels; |
| dst_texture_data.resize(dst_texture_size); |
| |
| /* Get texture contents */ |
| gl.bindTexture(GL_TEXTURE_2D, id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| gl.getTexImage(GL_TEXTURE_2D, 0 /* level */, format, type, &dst_texture_data[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage"); |
| |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| /* For each pixel */ |
| for (GLuint i = 0; i < n_pixels; ++i) |
| { |
| const GLuint dst_pixel_offset = dst_pixel_size * i; |
| const GLuint src_pixel_offset = src_pixel_size * i; |
| |
| const GLubyte* dst_pixel_data = &dst_texture_data[0] + dst_pixel_offset; |
| const GLubyte* src_pixel_data = &src_texture_data[0] + src_pixel_offset; |
| |
| if (true == is_stencil) /* Stencil channel */ |
| { |
| const GLubyte dst_stencil = dst_pixel_data[0]; |
| const GLubyte src_stencil = src_pixel_data[src_stencil_off]; |
| |
| if (src_stencil != dst_stencil) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Invalid pixel [" << i |
| << "], got: " << (GLuint)dst_stencil |
| << " expected: " << (GLuint)src_stencil << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| else /* Depth channel */ |
| { |
| if (GL_DEPTH24_STENCIL8 == source_internal_format) /* DEPTH24 */ |
| { |
| GLfloat dst_depth = 0.0f; |
| GLuint src_depth_i = 0; |
| GLfloat src_depth_f = 0.0f; |
| |
| memcpy(&dst_depth, dst_pixel_data, 4); |
| memcpy(&src_depth_i, src_pixel_data + 1, 3); |
| |
| src_depth_f = ((GLfloat)src_depth_i) / ((GLfloat)0xffffff); |
| |
| if (de::abs(src_depth_f - dst_depth) > 0.0001f) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Invalid pixel [" << i |
| << "], got: " << dst_depth << " expected: " << src_depth_f |
| << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| else /* DEPTH32F */ |
| { |
| GLfloat dst_depth = 0.0f; |
| GLfloat src_depth = 0.0f; |
| |
| memcpy(&dst_depth, dst_pixel_data, 4); |
| memcpy(&src_depth, src_pixel_data, 4); |
| |
| if (de::abs(src_depth - dst_depth) > 0.0001f) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Invalid pixel [" << i |
| << "], got: " << dst_depth << " expected: " << src_depth |
| << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| /** Test given internal format and channel |
| * |
| * @param internal_format Internal fromat of source texture |
| * @param is_stencil Selects if stencil or depth channel is sampled |
| * |
| * @return true if results from compute and draw programs are positive, false otherwise |
| **/ |
| bool FunctionalTest::test(GLenum internal_format, bool is_stencil) |
| { |
| GLuint compute_dst_tex_id = 0; |
| GLuint compute_program_id = 0; |
| GLuint compute_src_tex_id = 0; |
| GLuint draw_dst_tex_id = 0; |
| GLuint draw_program_id = 0; |
| GLuint draw_src_tex_id = 0; |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool test_result = true; |
| std::vector<GLubyte> texture_data; |
| |
| prepareSourceTextureData(internal_format, texture_data); |
| |
| try |
| { |
| if (true == Utils::isExtensionSupported(m_context, "GL_ARB_compute_shader")) |
| { |
| compute_dst_tex_id = prepareDestinationTexture(is_stencil); |
| compute_program_id = prepareProgram(false, is_stencil); |
| compute_src_tex_id = prepareSourceTexture(internal_format, is_stencil, texture_data); |
| |
| dispatch(compute_program_id, is_stencil, compute_dst_tex_id, compute_src_tex_id); |
| |
| if (false == verifyTexture(compute_dst_tex_id, internal_format, is_stencil, texture_data)) |
| { |
| test_result = false; |
| } |
| } |
| |
| { |
| draw_dst_tex_id = prepareDestinationTexture(is_stencil); |
| draw_program_id = prepareProgram(true, is_stencil); |
| draw_src_tex_id = prepareSourceTexture(internal_format, is_stencil, texture_data); |
| |
| draw(draw_program_id, draw_dst_tex_id, draw_src_tex_id); |
| |
| if (false == verifyTexture(draw_dst_tex_id, internal_format, is_stencil, texture_data)) |
| { |
| test_result = false; |
| } |
| } |
| } |
| catch (std::exception& exc) |
| { |
| gl.bindVertexArray(0); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); |
| gl.useProgram(0); |
| |
| Utils::deleteProgram(m_context, compute_program_id); |
| Utils::deleteProgram(m_context, draw_program_id); |
| |
| Utils::deleteTexture(m_context, compute_dst_tex_id); |
| Utils::deleteTexture(m_context, compute_src_tex_id); |
| Utils::deleteTexture(m_context, draw_dst_tex_id); |
| Utils::deleteTexture(m_context, draw_src_tex_id); |
| |
| TCU_FAIL(exc.what()); |
| } |
| |
| gl.bindVertexArray(0); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); |
| gl.useProgram(0); |
| |
| Utils::deleteProgram(m_context, compute_program_id); |
| Utils::deleteProgram(m_context, draw_program_id); |
| |
| Utils::deleteTexture(m_context, compute_dst_tex_id); |
| Utils::deleteTexture(m_context, compute_src_tex_id); |
| Utils::deleteTexture(m_context, draw_dst_tex_id); |
| Utils::deleteTexture(m_context, draw_src_tex_id); |
| |
| /* Done */ |
| return test_result; |
| } |
| } /* namespace StencilTexturing */ |
| |
| StencilTexturingTests::StencilTexturingTests(deqp::Context& context) : TestCaseGroup(context, "stencil_texturing", "") |
| { |
| } |
| |
| StencilTexturingTests::~StencilTexturingTests(void) |
| { |
| } |
| |
| void StencilTexturingTests::init() |
| { |
| addChild(new StencilTexturing::FunctionalTest(m_context)); |
| } |
| } /* namespace gl4cts */ |