| /*------------------------------------------------------------------------- |
| * 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 "esextcGeometryShaderClipping.hpp" |
| |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| #include <cstring> |
| |
| namespace glcts |
| { |
| /* Fragment shader code */ |
| const char* GeometryShaderClipping::m_fs_code = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result = vec4(0, 1, 0, 0);\n" |
| "}\n"; |
| |
| /* Vertex shader code */ |
| const char* GeometryShaderClipping::m_vs_code = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(-10, -10, -10, 0);\n" |
| "}\n"; |
| |
| /* Geometry shader code */ |
| const char* GeometryShaderClipping::m_gs_code = "${VERSION}\n" |
| "${GEOMETRY_SHADER_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices=4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "\n" |
| " gl_Position = vec4(1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_Position = vec4(1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's desricption |
| **/ |
| GeometryShaderClipping::GeometryShaderClipping(Context& context, const ExtParameters& extParams, const char* name, |
| const char* description) |
| : TestCaseBase(context, extParams, name, description) |
| , m_fbo_id(0) |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_po_id(0) |
| , m_to_id(0) |
| , m_vao_id(0) |
| , m_vs_id(0) |
| { |
| } |
| |
| /** Deinitializes GLES objects created during the test. |
| * |
| */ |
| void GeometryShaderClipping::deinit(void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Reset OpenGL ES state */ |
| gl.useProgram(0); |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0); |
| gl.bindVertexArray(0); |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| } |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| } |
| |
| if (m_to_id != 0) |
| { |
| gl.deleteTextures(1, &m_to_id); |
| } |
| |
| if (m_fbo_id != 0) |
| { |
| gl.deleteFramebuffers(1, &m_fbo_id); |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| } |
| |
| /* Release base class */ |
| TestCaseBase::deinit(); |
| } |
| |
| /** Executes the test. |
| * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. |
| * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. |
| * Note the function throws exception should an error occur! |
| **/ |
| tcu::TestNode::IterateResult GeometryShaderClipping::iterate(void) |
| { |
| unsigned char buffer[m_texture_width * m_texture_height * m_texture_n_components]; |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| const unsigned char reference_color[] = { 0, 255, 0, 0 }; |
| const unsigned int row_size = m_texture_width * m_texture_n_components; |
| |
| if (!m_is_geometry_shader_extension_supported) |
| { |
| throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| /* Create shader objects we'll need */ |
| m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); |
| m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER); |
| m_vs_id = gl.createShader(GL_VERTEX_SHADER); |
| m_po_id = gl.createProgram(); |
| |
| if (!buildProgram(m_po_id, m_fs_id, 1 /* part */, &m_fs_code, m_gs_id, 1 /* part */, &m_gs_code, m_vs_id, |
| 1 /* part */, &m_vs_code)) |
| { |
| TCU_FAIL("Could not create program object from valid vertex/geometry/fragment shaders!"); |
| } |
| |
| /* Create and configure texture object we'll be rendering to */ |
| gl.genTextures(1, &m_to_id); |
| gl.bindTexture(GL_TEXTURE_2D, m_to_id); |
| gl.texStorage2D(GL_TEXTURE_2D, m_texture_n_levels, GL_RGBA8, m_texture_width, m_texture_height); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating texture object!"); |
| |
| /* Create and configure the framebuffer object */ |
| gl.genFramebuffers(1, &m_fbo_id); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo_id); |
| gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring framebuffer object!"); |
| |
| /* Create and bind vertex array object */ |
| gl.genVertexArrays(1, &m_vao_id); |
| gl.bindVertexArray(m_vao_id); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring vertex array object"); |
| |
| /* Render */ |
| gl.viewport(0 /* x */, 0 /* y */, m_texture_width /* width */, m_texture_height /* height */); |
| gl.useProgram(m_po_id); |
| |
| gl.clearColor(1.0f, 0.0f, 0.0f, 0.0f); |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed!"); |
| |
| /* Read the rendered data */ |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_id); |
| gl.readPixels(0 /* x */, 0 /* y */, m_texture_height /* width */, m_texture_width /* height */, GL_RGBA, |
| GL_UNSIGNED_BYTE, buffer); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels failed!"); |
| |
| /* Loop over all pixels and compare the rendered data with reference value */ |
| for (int y = 0; y < m_texture_height; ++y) |
| { |
| unsigned char* data_row = buffer + y * row_size; |
| |
| for (int x = 0; x < m_texture_width; ++x) |
| { |
| unsigned char* data = data_row + x * m_texture_n_components; |
| |
| if (memcmp(data, reference_color, sizeof(reference_color)) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Rendered data [" << data[0] << ", " << data[1] << ", " |
| << data[2] << ", " << data[3] << "] is different from reference data [" |
| << reference_color[0] << ", " << reference_color[1] << ", " << reference_color[2] |
| << ", " << reference_color[3] << "] !" << tcu::TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| |
| return STOP; |
| } /* if (memcmp(data, reference_color, sizeof(reference_color)) != 0) */ |
| } /* for (all columns) */ |
| } /* for (all rows) */ |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| } // namespace glcts |