| /*------------------------------------------------------------------------- |
| * 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 "esextcGeometryShaderPrimitiveCounter.hpp" |
| #include "deMath.h" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| #include <string.h> |
| |
| namespace glcts |
| { |
| /* Fragment shader code */ |
| const char* GeometryShaderPrimitiveCounter::m_fragment_shader_code = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(location = 0) out vec4 color;\n" |
| "\n" |
| "flat in int test_gl_PrimitiveIDIn;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " color = vec4(1, 1, 1, 1);\n" |
| "}\n"; |
| |
| /* Vertex shader code */ |
| const char* GeometryShaderPrimitiveCounter::m_vertex_shader_code = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "in vec4 vertex_position;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vertex_position;\n" |
| "}\n"; |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test group's name |
| * @param description Test group's desricption |
| **/ |
| GeometryShaderPrimitiveCounterTestGroup::GeometryShaderPrimitiveCounterTestGroup(Context& context, |
| const ExtParameters& extParams, |
| const char* name, |
| const char* description) |
| : TestCaseGroupBase(context, extParams, name, description) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Initializes the test group creating test cases that this group consists of |
| **/ |
| void GeometryShaderPrimitiveCounterTestGroup::init(void) |
| { |
| DataPrimitiveIDInCounter testConfiguration; |
| |
| /* Test case 6.1 */ |
| |
| /* Points-to-Points Configuration */ |
| testConfiguration.m_drawMode = GL_POINTS; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_POINTS; |
| testConfiguration.m_layoutIn = "points"; |
| testConfiguration.m_layoutOut = "points"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 1; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 1; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "point_to_point", |
| "Test Group 6.1 points to points", testConfiguration)); |
| |
| /* Points-to-Line Strip Configuration*/ |
| testConfiguration.m_drawMode = GL_POINTS; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_LINES; |
| testConfiguration.m_layoutIn = "points"; |
| testConfiguration.m_layoutOut = "line_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 2; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 1; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "points_to_line_strip", |
| "Test Group 6.1 points to line strip", testConfiguration)); |
| |
| /* Points-to-Triangle Strip Configuration */ |
| testConfiguration.m_drawMode = GL_POINTS; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_TRIANGLES; |
| testConfiguration.m_layoutIn = "points"; |
| testConfiguration.m_layoutOut = "triangle_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 3; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 1; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "points_to_triangle_strip", |
| "Test Group 6.1 points to triangle strip", testConfiguration)); |
| |
| /* Lines-to-Points Configuration */ |
| testConfiguration.m_drawMode = GL_LINES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_POINTS; |
| testConfiguration.m_layoutIn = "lines"; |
| testConfiguration.m_layoutOut = "points"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 1; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 2; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "lines_to_points", |
| "Test Group 6.1 lines to points", testConfiguration)); |
| |
| /* Lines-to-Line Strip Configuration */ |
| testConfiguration.m_drawMode = GL_LINES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_LINES; |
| testConfiguration.m_layoutIn = "lines"; |
| testConfiguration.m_layoutOut = "line_strip"; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 2; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 2; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "lines_to_line_strip", |
| "Test Group 6.1 lines to line strip", testConfiguration)); |
| |
| /* Lines-to-Triangle Strip Configuration */ |
| testConfiguration.m_drawMode = GL_LINES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_TRIANGLES; |
| testConfiguration.m_layoutIn = "lines"; |
| testConfiguration.m_layoutOut = "triangle_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 3; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 2; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "lines_to_triangle_strip", |
| "Test Group 6.1 lines to triangle strip", testConfiguration)); |
| |
| /* Triangles-to-Points Configuration */ |
| testConfiguration.m_drawMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_POINTS; |
| testConfiguration.m_layoutIn = "triangles"; |
| testConfiguration.m_layoutOut = "points"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 1; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 3; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "triangles_to_points", |
| "Test Group 6.1 triangles to points", testConfiguration)); |
| |
| /* Triangles-to-Line Strip Configuration */ |
| testConfiguration.m_drawMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_LINES; |
| testConfiguration.m_layoutIn = "triangles"; |
| testConfiguration.m_layoutOut = "line_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 2; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 3; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "triangles_to_line_strip", |
| "Test Group 6.1 triangles to line strip", testConfiguration)); |
| |
| /* Triangles-to-Triangle Strip Configuration */ |
| testConfiguration.m_drawMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn=gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn=gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn=gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[2].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_TRIANGLES; |
| testConfiguration.m_layoutIn = "triangles"; |
| testConfiguration.m_layoutOut = "triangle_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 3; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 3; |
| |
| addChild(new GeometryShaderPrimitiveCounter(getContext(), m_extParams, "triangles_to_triangle_strip", |
| "Test Group 6.1 triangles to triangle strip", testConfiguration)); |
| |
| /* Test case 6.2 */ |
| |
| /* Points-to-Points Configuration */ |
| testConfiguration.m_drawMode = GL_POINTS; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_POINTS; |
| testConfiguration.m_layoutIn = "points"; |
| testConfiguration.m_layoutOut = "points"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 1; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 1; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "points_to_points_rp", "Test Group 6.2 points to points", testConfiguration)); |
| |
| /* Points-to-Line Strip Configuration */ |
| testConfiguration.m_drawMode = GL_POINTS; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_LINES; |
| testConfiguration.m_layoutIn = "points"; |
| testConfiguration.m_layoutOut = "line_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 2; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 1; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive(getContext(), m_extParams, "points_to_line_strip_rp", |
| "Test Group 6.2 point to line", testConfiguration)); |
| |
| /* Points-to-Triangle Strip Configuration */ |
| testConfiguration.m_drawMode = GL_POINTS; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_TRIANGLES; |
| testConfiguration.m_layoutIn = "points"; |
| testConfiguration.m_layoutOut = "triangle_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 3; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 1; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "points_to_triangle_strip_rp", "Test Group 6.2 points to triangle strip", |
| testConfiguration)); |
| |
| /* Lines-to-Points Configuration */ |
| testConfiguration.m_layoutIn = "lines"; |
| testConfiguration.m_layoutOut = "points"; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 1; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 2; |
| testConfiguration.m_feedbackMode = GL_POINTS; |
| testConfiguration.m_drawMode = GL_LINES; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "lines_to_points_rp", "Test Group 6.2 lines to points", testConfiguration)); |
| |
| /* Lines to Line Strip Configuration*/ |
| testConfiguration.m_drawMode = GL_LINES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_LINES; |
| testConfiguration.m_layoutIn = "lines"; |
| testConfiguration.m_layoutOut = "line_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 2; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 2; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "lines_to_line_strip_rp", "Test Group 6.2 lines to line strip", testConfiguration)); |
| |
| /* Lines to Triangle Strip Configuration */ |
| testConfiguration.m_drawMode = GL_LINES; |
| testConfiguration.m_feedbackMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_layoutIn = "lines"; |
| testConfiguration.m_layoutOut = "triangle_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 3; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 2; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "lines_to_triangle_strip_rp", "Test Group 6.2 line to triangle", testConfiguration)); |
| |
| /* Triangles to Points Configuration */ |
| testConfiguration.m_drawMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_POINTS; |
| testConfiguration.m_layoutIn = "triangles"; |
| testConfiguration.m_layoutOut = "points"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 1; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 3; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "triangles_to_points_rp", "Test Group 6.2 triangles to points", testConfiguration)); |
| |
| /* Triangles to Line Strip Configuration */ |
| testConfiguration.m_drawMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_LINES; |
| testConfiguration.m_layoutIn = "triangles"; |
| testConfiguration.m_layoutOut = "line_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 2; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 3; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "triangles_to_line_strip_rp", "Test Group 6.2 triangles to line strip", |
| testConfiguration)); |
| |
| /* Triangles to Triangle Strip Configuration*/ |
| testConfiguration.m_drawMode = GL_TRIANGLES; |
| testConfiguration.m_emitVertexCodeForGeometryShader = " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[1].gl_Position;\n" |
| " EmitVertex();\n" |
| "\n" |
| " test_gl_PrimitiveIDIn = gl_PrimitiveIDIn;\n" |
| " gl_Position = gl_in[2].gl_Position;\n" |
| " EmitVertex();\n"; |
| testConfiguration.m_feedbackMode = GL_TRIANGLES; |
| testConfiguration.m_layoutIn = "triangles"; |
| testConfiguration.m_layoutOut = "triangle_strip"; |
| testConfiguration.m_numberOfDrawnPrimitives = 1024; |
| testConfiguration.m_numberOfVerticesPerOneOutputPrimitive = 3; |
| testConfiguration.m_numberOfVerticesPerOneInputPrimitive = 3; |
| |
| addChild(new GeometryShaderPrimitiveCounterRestartingPrimitive( |
| getContext(), m_extParams, "triangles_to_triangle_strip_rp", "Test Group 6.2 triangles to triangle strip", |
| testConfiguration)); |
| |
| /* Test case 6.3 */ |
| addChild(new GeometryShaderPrimitiveIDFromFragmentShader(getContext(), m_extParams, "primitive_id_from_fragment", |
| "Test Group 6.3 gl_PrimitiveID from fragment shader")); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| * @param testConfiguration Configuration that specifies the "in" and "out" primitive types |
| * for the geometry shader and the shader itself |
| **/ |
| GeometryShaderPrimitiveCounter::GeometryShaderPrimitiveCounter(Context& context, const ExtParameters& extParams, |
| const char* name, const char* description, |
| const DataPrimitiveIDInCounter& testConfiguration) |
| : TestCaseBase(context, extParams, name, description) |
| , m_testConfiguration(testConfiguration) |
| , m_nrVaryings(0) |
| , m_sizeOfDataArray(0) |
| , m_sizeOfFeedbackBuffer(0) |
| , m_n_components(4) |
| , m_maxGeometryOutputVertices(0) |
| , m_fragment_shader_id(0) |
| , m_geometry_shader_id(0) |
| , m_vertex_shader_id(0) |
| , m_program_id(0) |
| , m_tbo(0) |
| , m_vao(0) |
| , m_vbo(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Verifies the data generated by XFB during a draw call. |
| * |
| * @param data Input data. Must not be NULL. |
| * |
| * @return true if successful, false otherwise. |
| */ |
| bool GeometryShaderPrimitiveCounter::checkResult(const glw::GLint* data) |
| { |
| bool testPassed = true; |
| |
| for (unsigned int nDrawnPrimitive = 0; nDrawnPrimitive < m_testConfiguration.m_numberOfDrawnPrimitives; |
| nDrawnPrimitive++) |
| { |
| unsigned int nEmittedValuesPerPrimitive = m_maxGeometryOutputVertices * m_nrVaryings; |
| |
| for (unsigned int nValue = (nEmittedValuesPerPrimitive * (nDrawnPrimitive)); |
| nValue < (nEmittedValuesPerPrimitive * (nDrawnPrimitive + 1)); nValue++) |
| { |
| if ((unsigned int)data[nValue] != nDrawnPrimitive) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Rendered value at index " |
| << "[" << nValue << "/" << (m_testConfiguration.m_numberOfDrawnPrimitives * |
| m_maxGeometryOutputVertices * m_nrVaryings) |
| << "]: " << data[nValue] << " != " << nEmittedValuesPerPrimitive |
| << tcu::TestLog::EndMessage; |
| |
| testPassed = false; |
| } |
| } /* for (all values) */ |
| } /* for (all primitives) */ |
| |
| return testPassed; |
| } |
| |
| /** Creates a program object using predefined fragment & vertex shaders |
| * and a geometry shader that is constructed on-the-fly, according |
| * to testConfiguration parameters. The function also sets up transform |
| * feedback varyings, prior to linking. |
| **/ |
| void GeometryShaderPrimitiveCounter::createAndBuildProgramWithFeedback(void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create a program object */ |
| m_program_id = gl.createProgram(); |
| |
| /* Specify transform feedback varyings */ |
| const char* feedbackVaryings[] = { "test_gl_PrimitiveIDIn" }; |
| |
| m_nrVaryings = sizeof(feedbackVaryings) / sizeof(char*); |
| |
| gl.transformFeedbackVaryings(m_program_id, m_nrVaryings, feedbackVaryings, GL_INTERLEAVED_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set transform feedback varyings!"); |
| |
| /* Create shader objects that will make up the program object */ |
| m_geometry_shader_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER); |
| m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); |
| m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed"); |
| |
| /* Retrieve GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT pname value and use it as argument for |
| * max_vertices layout qualifier of the geometry shader. */ |
| std::stringstream max_vertices_sstream; |
| std::string max_vertices_string; |
| |
| gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_OUTPUT_VERTICES, &m_maxGeometryOutputVertices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not query GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT!"); |
| |
| m_maxGeometryOutputVertices = m_maxGeometryOutputVertices / (m_n_components + m_nrVaryings); |
| |
| max_vertices_sstream << m_maxGeometryOutputVertices; |
| max_vertices_string = max_vertices_sstream.str(); |
| |
| /* Calculate the possible for loops count in Geometry Shader */ |
| glw::GLint n_loop_iterations = |
| m_maxGeometryOutputVertices / m_testConfiguration.m_numberOfVerticesPerOneOutputPrimitive; |
| |
| /* adjust the m_maxGeometryOutputVertices to be the number of emitted vertices */ |
| m_maxGeometryOutputVertices = n_loop_iterations * m_testConfiguration.m_numberOfVerticesPerOneOutputPrimitive; |
| |
| std::stringstream n_loop_iterations_sstream; |
| std::string n_loop_iterations_string; |
| |
| n_loop_iterations_sstream << n_loop_iterations; |
| n_loop_iterations_string = n_loop_iterations_sstream.str(); |
| |
| /* Construct geometry shader code */ |
| std::string geometry_shader_code = |
| GetGeometryShaderCode(max_vertices_string, m_testConfiguration.m_layoutIn, m_testConfiguration.m_layoutOut, |
| m_testConfiguration.m_emitVertexCodeForGeometryShader, n_loop_iterations_string); |
| |
| const char* geometry_shader_code_ptr = (const char*)geometry_shader_code.c_str(); |
| |
| /* Build program */ |
| if (!buildProgram(m_program_id, m_fragment_shader_id, 1, &m_fragment_shader_code, m_geometry_shader_id, 1, |
| &geometry_shader_code_ptr, m_vertex_shader_id, 1, &m_vertex_shader_code)) |
| { |
| TCU_FAIL("Program could not have been created sucessfully"); |
| } |
| } |
| |
| /** Deinitializes GLES objects created during the test. |
| * |
| */ |
| void GeometryShaderPrimitiveCounter::deinit(void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Reset OpenGL ES state */ |
| gl.useProgram(0); |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| gl.bindVertexArray(0); |
| |
| /* Delete program object and shader objects */ |
| if (m_program_id != 0) |
| { |
| gl.deleteProgram(m_program_id); |
| } |
| |
| if (m_vertex_shader_id != 0) |
| { |
| gl.deleteShader(m_vertex_shader_id); |
| } |
| |
| if (m_geometry_shader_id != 0) |
| { |
| gl.deleteShader(m_geometry_shader_id); |
| } |
| |
| if (m_fragment_shader_id != 0) |
| { |
| gl.deleteShader(m_fragment_shader_id); |
| } |
| |
| if (m_vbo != 0) |
| { |
| gl.deleteBuffers(1, &m_vbo); |
| } |
| |
| if (m_tbo != 0) |
| { |
| gl.deleteBuffers(1, &m_tbo); |
| } |
| |
| if (m_vao != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao); |
| } |
| |
| /* Deinitialize base class */ |
| TestCaseBase::deinit(); |
| } |
| |
| /** Render a test geometry and retrieve data generated by XFB. |
| * |
| * @param feedbackResult Will be filled with data generated by XFB. |
| * Must provide m_sizeOfFeedbackBuffer bytes of space. |
| * Must not be NULL. |
| */ |
| void GeometryShaderPrimitiveCounter::drawAndGetFeedback(glw::GLint* feedbackResult) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.useProgram(m_program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed!"); |
| |
| gl.enable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) failed!"); |
| |
| /* Perform transform feedback */ |
| gl.beginTransformFeedback(m_testConfiguration.m_feedbackMode); |
| { |
| drawFunction(); |
| } |
| gl.endTransformFeedback(); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed"); |
| |
| gl.disable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "giDisable(GL_RASTERIZER_DISCARD) failed"); |
| |
| /* Fetch the generated data */ |
| glw::GLint* feedback = NULL; |
| |
| feedback = (glw::GLint*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* offset */ |
| m_sizeOfFeedbackBuffer, GL_MAP_READ_BIT); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); |
| |
| memcpy(feedbackResult, feedback, m_sizeOfFeedbackBuffer); |
| |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed"); |
| } |
| |
| /** Renders the test geometry. |
| * |
| */ |
| void GeometryShaderPrimitiveCounter::drawFunction() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.drawArrays(m_testConfiguration.m_drawMode, 0, /* first */ |
| m_testConfiguration.m_numberOfDrawnPrimitives * |
| m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive); |
| } |
| |
| /** Fill geometry shader template |
| * |
| * @param max_vertices String in "max_vertices=N" format (where N is a valid value); |
| * @param layout_in String storing an "in" layout qualifier definition; |
| * @param layout_out String storing an "out" layout qualifier definition; |
| * @param emit_vertices String storing the vertex emitting code; |
| * @param n_iterations String storing a number of vertex emitting iterations; |
| */ |
| std::string GeometryShaderPrimitiveCounter::GetGeometryShaderCode(const std::string& max_vertices, |
| const std::string& layout_in, |
| const std::string& layout_out, |
| const std::string& emit_vertices, |
| const std::string& n_iterations) |
| { |
| /* Geometry shader template code */ |
| std::string m_geometry_shader_template = "${VERSION}\n" |
| "\n" |
| "${GEOMETRY_SHADER_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(<-LAYOUT-IN->) in;\n" |
| "layout(<-LAYOUT-OUT->, max_vertices =<-MAX-VERTICES->) out;\n" |
| "\n" |
| "flat out int test_gl_PrimitiveIDIn;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " for (int i=0; i<<-N_ITERATIONS->; i++)\n" |
| " {\n" |
| " <-EMIT-VERTICES->\n" |
| " EndPrimitive();\n" |
| " }\n" |
| "}\n"; |
| |
| /* Max number of emited vertices */ |
| std::string template_name = "<-MAX-VERTICES->"; |
| std::size_t template_position = m_geometry_shader_template.find(template_name); |
| |
| while (template_position != std::string::npos) |
| { |
| m_geometry_shader_template = |
| m_geometry_shader_template.replace(template_position, template_name.length(), max_vertices); |
| |
| template_position = m_geometry_shader_template.find(template_name); |
| } |
| |
| /* In primitive type */ |
| template_name = "<-LAYOUT-IN->"; |
| template_position = m_geometry_shader_template.find(template_name); |
| |
| while (template_position != std::string::npos) |
| { |
| m_geometry_shader_template = |
| m_geometry_shader_template.replace(template_position, template_name.length(), layout_in); |
| |
| template_position = m_geometry_shader_template.find(template_name); |
| } |
| |
| /* Out primitive type */ |
| template_name = "<-LAYOUT-OUT->"; |
| template_position = m_geometry_shader_template.find(template_name); |
| |
| while (template_position != std::string::npos) |
| { |
| m_geometry_shader_template = |
| m_geometry_shader_template.replace(template_position, template_name.length(), layout_out); |
| |
| template_position = m_geometry_shader_template.find(template_name); |
| } |
| |
| /* Vertex emit code */ |
| template_name = "<-EMIT-VERTICES->"; |
| template_position = m_geometry_shader_template.find(template_name); |
| |
| while (template_position != std::string::npos) |
| { |
| m_geometry_shader_template = |
| m_geometry_shader_template.replace(template_position, template_name.length(), emit_vertices); |
| |
| template_position = m_geometry_shader_template.find(template_name); |
| } |
| |
| /* Number of iterations, during which we'll be emitting vertices */ |
| template_name = "<-N_ITERATIONS->"; |
| template_position = m_geometry_shader_template.find(template_name); |
| |
| while (template_position != std::string::npos) |
| { |
| m_geometry_shader_template = |
| m_geometry_shader_template.replace(template_position, template_name.length(), n_iterations); |
| |
| template_position = m_geometry_shader_template.find(template_name); |
| } |
| |
| return m_geometry_shader_template; |
| } |
| |
| /** 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 GeometryShaderPrimitiveCounter::iterate(void) |
| { |
| if (!m_is_geometry_shader_extension_supported) |
| { |
| throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| /* Set up */ |
| glw::GLint* feedbackResult = NULL; |
| |
| createAndBuildProgramWithFeedback(); |
| prepareBufferObjects(); |
| |
| feedbackResult = new glw::GLint[m_sizeOfFeedbackBuffer]; |
| |
| /* Execute the test */ |
| drawAndGetFeedback(feedbackResult); |
| |
| /* Set the CTS test result, depending on the outcome */ |
| if (checkResult(feedbackResult)) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| if (feedbackResult != NULL) |
| { |
| delete[] feedbackResult; |
| |
| feedbackResult = DE_NULL; |
| } |
| |
| return STOP; |
| } |
| |
| /** Prepare buffer objects and initialize their storage. It will |
| * later be used as vertex attribute array data source, as well |
| * as transform feedback destination. |
| **/ |
| void GeometryShaderPrimitiveCounter::prepareBufferObjects() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create a VAO */ |
| gl.genVertexArrays(1, &m_vao); |
| gl.bindVertexArray(m_vao); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a VAO!"); |
| |
| m_sizeOfDataArray = m_testConfiguration.m_numberOfDrawnPrimitives * m_n_components * |
| m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive; |
| |
| gl.genBuffers(1, &m_vbo); |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_vbo); |
| gl.bufferData(GL_ARRAY_BUFFER, m_sizeOfDataArray * sizeof(glw::GLfloat), NULL, GL_STATIC_DRAW); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), |
| "Could not initialize a buffer object to hold data for vertex_position attribute!"); |
| |
| /* Set up "vertex_position" vertex attribute array */ |
| glw::GLint vertex_position_attribute_location = -1; |
| |
| vertex_position_attribute_location = gl.getAttribLocation(m_program_id, "vertex_position"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not retrieve vertex_position attribute location!"); |
| |
| gl.vertexAttribPointer(vertex_position_attribute_location, 4, /* size */ |
| GL_FLOAT, GL_FALSE, /* normalized */ |
| 0, /* stride */ |
| 0); /* pointer */ |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() failed for vertex_position attribute!"); |
| |
| gl.enableVertexAttribArray(vertex_position_attribute_location); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() failed for vertex_position attribute!"); |
| |
| /* Set up buffer object to hold result transform feedback data */ |
| m_sizeOfFeedbackBuffer = static_cast<glw::GLuint>(m_testConfiguration.m_numberOfDrawnPrimitives * |
| m_maxGeometryOutputVertices * m_nrVaryings * sizeof(glw::GLint)); |
| |
| gl.genBuffers(1, &m_tbo); |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_tbo); |
| gl.bufferData(GL_ARRAY_BUFFER, m_sizeOfFeedbackBuffer, DE_NULL, GL_STATIC_COPY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up a buffer object to hold transform feedback data!"); |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_tbo); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind a buffer object to transform feedback binding point!"); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context; |
| * @param name Test case's name; |
| * @param description Test case's description; |
| * @param testConfiguration Configuration that specifies the "in" and "out" primitive type |
| * for the geometry shader, as well as defines other miscellaneous |
| * properties of the test the shader. |
| **/ |
| GeometryShaderPrimitiveCounterRestartingPrimitive::GeometryShaderPrimitiveCounterRestartingPrimitive( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description, |
| const DataPrimitiveIDInCounter& testConfiguration) |
| : GeometryShaderPrimitiveCounter(context, extParams, name, description, testConfiguration) |
| , m_bo_id(0) |
| , m_numberOfRestarts(2) |
| { |
| } |
| |
| /** Deinitializes GLES objects created during the test. |
| * |
| */ |
| void GeometryShaderPrimitiveCounterRestartingPrimitive::deinit(void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_bo_id != 0) |
| { |
| gl.deleteBuffers(1, &m_bo_id); |
| |
| m_bo_id = 0; |
| } |
| |
| /* Call base class' deinit() */ |
| GeometryShaderPrimitiveCounter::deinit(); |
| } |
| |
| /** Renders the test geometry. |
| * |
| */ |
| void GeometryShaderPrimitiveCounterRestartingPrimitive::drawFunction() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.drawElements(m_testConfiguration.m_drawMode, (m_testConfiguration.m_numberOfDrawnPrimitives * |
| m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive + |
| m_numberOfRestarts), |
| GL_UNSIGNED_INT, 0 /* indices */); |
| } |
| |
| /** 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 GeometryShaderPrimitiveCounterRestartingPrimitive::iterate(void) |
| { |
| if (!m_is_geometry_shader_extension_supported) |
| { |
| throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| /* Set up */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| createAndBuildProgramWithFeedback(); |
| prepareBufferObjects(); |
| |
| glw::GLenum restart_token; |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| restart_token = GL_PRIMITIVE_RESTART; |
| } |
| else |
| { |
| restart_token = GL_PRIMITIVE_RESTART_FIXED_INDEX; |
| } |
| |
| gl.enable(restart_token); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Enabling primitive restart failed"); |
| |
| setUpVertexAttributeArrays(); |
| |
| /* Render the test geometry */ |
| glw::GLint* feedbackResult = NULL; |
| feedbackResult = new glw::GLint[m_sizeOfFeedbackBuffer]; |
| try |
| { |
| drawAndGetFeedback(feedbackResult); |
| } |
| catch (...) |
| { |
| delete[] feedbackResult; |
| feedbackResult = NULL; |
| throw; |
| } |
| |
| gl.disable(restart_token); |
| |
| int error = gl.getError(); |
| if (error != GL_NO_ERROR) |
| { |
| delete[] feedbackResult; |
| feedbackResult = NULL; |
| GLU_EXPECT_NO_ERROR(error, "Disabling primitive restart failed"); |
| } |
| |
| /* Check the result and update the DEQP test result accordingly */ |
| if (checkResult(feedbackResult)) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| delete[] feedbackResult; |
| feedbackResult = NULL; |
| |
| return STOP; |
| } |
| |
| /** Prepare the element vertex attribute array data. Make sure to |
| * use primitive index functionality. |
| */ |
| void GeometryShaderPrimitiveCounterRestartingPrimitive::setUpVertexAttributeArrays() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create a buffer object to hold the element data */ |
| glw::GLuint* indices = DE_NULL; |
| const unsigned int nIndices = |
| m_testConfiguration.m_numberOfDrawnPrimitives * m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive + |
| m_numberOfRestarts; |
| unsigned int restartIndex; |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| restartIndex = nIndices; |
| } |
| else |
| { |
| restartIndex = 0xFFFFFFFF; |
| } |
| |
| gl.genBuffers(1, &m_bo_id); |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate a buffer object"); |
| |
| /* Prepare the data we will later use for configuring buffer object storage contents */ |
| indices = new unsigned int[nIndices]; |
| memset(indices, 0, nIndices * sizeof(unsigned int)); |
| |
| for (unsigned int restartNr = 0; restartNr < m_numberOfRestarts; ++restartNr) |
| { |
| for (unsigned int i = m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive * restartNr + 1; i < nIndices; |
| i++) |
| { |
| if (i < m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive * (restartNr + 1) + restartNr) |
| { |
| indices[i] = i - restartNr; |
| } |
| else if (i > m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive * (restartNr + 1) + restartNr) |
| { |
| indices[i] = (i - 1 - restartNr); |
| } |
| } |
| indices[m_testConfiguration.m_numberOfVerticesPerOneInputPrimitive * (restartNr + 1) + restartNr] = |
| restartIndex; |
| } |
| |
| /* |
| m_testCtx.getLog() << tcu::TestLog::Message << "Indices table [ " << tcu::TestLog::EndMessage; |
| for (unsigned int i = 0; i < nIndices; i++) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << indices[i] << ", " << tcu::TestLog::EndMessage; |
| } |
| m_testCtx.getLog() << tcu::TestLog::Message << " ]" << tcu::TestLog::EndMessage; |
| */ |
| |
| /* Set up buffer object data storage */ |
| gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(glw::GLuint) * nIndices, indices, GL_STATIC_DRAW); |
| /* Free the buffer we no longer need */ |
| delete[] indices; |
| indices = NULL; |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create element array buffer object"); |
| |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| /* Set up primitive restarting */ |
| gl.primitiveRestartIndex(restartIndex); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set primitive restart index"); |
| } |
| } |
| |
| /* Vertex shader code */ |
| const char* GeometryShaderPrimitiveIDFromFragmentShader::m_vertex_shader_code = "${VERSION}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "flat out int vs_vertex_id;" |
| "\n" |
| " in vec4 vertex_position;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vs_vertex_id = gl_VertexID;" |
| "}\n"; |
| |
| /* Geometry Shader code */ |
| const char* GeometryShaderPrimitiveIDFromFragmentShader::m_geometry_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GEOMETRY_SHADER_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "flat in int vs_vertex_id[1];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " int column = vs_vertex_id[0] % 64;\n" |
| " int row = vs_vertex_id[0] / 64;\n" |
| "\n" |
| " gl_PrimitiveID = vs_vertex_id[0];\n" |
| " gl_Position = vec4(-1.0 + float(column+1) / 32.0, -1.0 + float(row + 1) / 32.0, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_PrimitiveID = vs_vertex_id[0];\n" |
| " gl_Position = vec4(-1.0 + float(column+1) / 32.0, -1.0 + float(row) / 32.0, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_PrimitiveID = vs_vertex_id[0];\n" |
| " gl_Position = vec4(-1.0 + float(column) / 32.0, -1.0 + float(row + 1) / 32.0, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_PrimitiveID = vs_vertex_id[0];\n" |
| " gl_Position = vec4(-1.0 + float(column)/ 32.0, -1.0 + float(row)/ 32.0, 0, 1);\n" |
| " EmitVertex();\n" |
| "\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| |
| /* Fragment shader code */ |
| const char* GeometryShaderPrimitiveIDFromFragmentShader::m_fragment_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GEOMETRY_SHADER_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(location = 0) out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result.x = float(gl_PrimitiveID % 64) / 64.0f;\n" |
| " result.y = floor(float(gl_PrimitiveID) / 64.0f) / 64.0f;\n" |
| " result.z = float(gl_PrimitiveID) / 4096.0f;\n" |
| " result.w = ((gl_PrimitiveID % 2) == 0) ? 1.0f : 0.0f;\n" |
| "}\n"; |
| |
| /** Constructor |
| * |
| * @param context Test context; |
| * @param name Test case's name; |
| * @param description Test case's description; |
| **/ |
| GeometryShaderPrimitiveIDFromFragmentShader::GeometryShaderPrimitiveIDFromFragmentShader(Context& context, |
| const ExtParameters& extParams, |
| const char* name, |
| const char* description) |
| : TestCaseBase(context, extParams, name, description) |
| , m_n_drawn_vertices(4096) |
| , m_squareEdgeSize(16) |
| , m_texture_height(1024) |
| , m_texture_n_components(4) |
| , m_texture_n_levels(1) |
| , m_texture_width(1024) |
| , m_fbo_id(0) |
| , m_fragment_shader_id(0) |
| , m_geometry_shader_id(0) |
| , m_program_id(0) |
| , m_texture_id(0) |
| , m_vao_id(0) |
| , m_vbo_id(0) |
| , m_vertex_shader_id(0) |
| { |
| } |
| |
| /** Deinitializes GLES objects created during the test. |
| * |
| */ |
| void GeometryShaderPrimitiveIDFromFragmentShader::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_program_id != 0) |
| { |
| gl.deleteProgram(m_program_id); |
| |
| m_program_id = 0; |
| } |
| |
| if (m_fragment_shader_id != 0) |
| { |
| gl.deleteShader(m_fragment_shader_id); |
| |
| m_fragment_shader_id = 0; |
| } |
| |
| if (m_geometry_shader_id != 0) |
| { |
| gl.deleteShader(m_geometry_shader_id); |
| |
| m_geometry_shader_id = 0; |
| } |
| |
| if (m_vertex_shader_id != 0) |
| { |
| gl.deleteShader(m_vertex_shader_id); |
| |
| m_vertex_shader_id = 0; |
| } |
| |
| if (m_texture_id != 0) |
| { |
| gl.deleteTextures(1, &m_texture_id); |
| |
| m_texture_id = 0; |
| } |
| |
| if (m_fbo_id != 0) |
| { |
| gl.deleteFramebuffers(1, &m_fbo_id); |
| |
| m_fbo_id = 0; |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| |
| if (m_vbo_id != 0) |
| { |
| gl.deleteBuffers(1, &m_vbo_id); |
| |
| m_vbo_id = 0; |
| } |
| |
| /* 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 GeometryShaderPrimitiveIDFromFragmentShader::iterate(void) |
| { |
| const float epsilon = 1.0f / 256.0f; |
| |
| if (!m_is_geometry_shader_extension_supported) |
| { |
| throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create a program object */ |
| m_program_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() failed"); |
| |
| /* Create shader objects */ |
| m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); |
| m_geometry_shader_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER); |
| m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed"); |
| |
| /* Build the program object */ |
| if (!buildProgram(m_program_id, m_fragment_shader_id, 1, &m_fragment_shader_code, m_geometry_shader_id, 1, |
| &m_geometry_shader_code, m_vertex_shader_id, 1, &m_vertex_shader_code)) |
| { |
| TCU_FAIL("Program could not have been created sucessfully"); |
| } |
| |
| /* Create and configure a texture object we'll be rendering to */ |
| gl.genTextures(1, &m_texture_id); |
| gl.bindTexture(GL_TEXTURE_2D, m_texture_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 a 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_texture_id, 0 /* level */); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring framebuffer object!"); |
| |
| /* Create and bind a vertex array object */ |
| gl.genVertexArrays(1, &m_vao_id); |
| gl.bindVertexArray(m_vao_id); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring a vertex array object"); |
| |
| /* Set up a buffer object we will use to hold vertex_position attribute data */ |
| const glw::GLuint sizeOfDataArray = |
| static_cast<glw::GLuint>(m_n_drawn_vertices * m_texture_n_components * sizeof(glw::GLfloat)); |
| |
| gl.genBuffers(1, &m_vbo_id); |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_vbo_id); |
| gl.bufferData(GL_ARRAY_BUFFER, sizeOfDataArray, DE_NULL, GL_STATIC_DRAW); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up a buffer object to hold vertex_position attribute data!"); |
| |
| /* Set up the viewport */ |
| gl.viewport(0 /* x */, 0 /* y */, m_texture_width, m_texture_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed"); |
| |
| /* Clear the color buffer */ |
| gl.clearColor(1.0f, 1.0f, 1.0f, 1.0f); |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not clear the color buffer!"); |
| |
| /* Render the test geometry */ |
| gl.useProgram(m_program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, m_n_drawn_vertices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed!"); |
| |
| /* Read the rendered data */ |
| glw::GLubyte* resultBuffer = new glw::GLubyte[m_texture_width * m_texture_height * m_texture_n_components]; |
| |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_id); |
| int error = gl.getError(); |
| if (error != GL_NO_ERROR) |
| { |
| delete[] resultBuffer; |
| resultBuffer = NULL; |
| GLU_EXPECT_NO_ERROR(error, "glBindFramebuffer() call failed"); |
| } |
| |
| gl.readPixels(0 /* x */, 0 /* y */, m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, resultBuffer); |
| |
| error = gl.getError(); |
| if (error != GL_NO_ERROR) |
| { |
| delete[] resultBuffer; |
| resultBuffer = NULL; |
| GLU_EXPECT_NO_ERROR(error, "Reading pixels failed!"); |
| } |
| |
| /* Loop over all pixels and compare the rendered data with reference values */ |
| for (glw::GLuint y = 0; y < m_texture_height; ++y) |
| { |
| glw::GLubyte* data_row = resultBuffer + y * m_texture_width * m_texture_n_components; |
| |
| for (glw::GLuint x = 0; x < m_texture_width; ++x) |
| { |
| glw::GLuint column = (x / m_squareEdgeSize); |
| glw::GLubyte* data = data_row + x * m_texture_n_components; |
| glw::GLuint row = (y / m_squareEdgeSize); |
| glw::GLuint primitiveID = column + (row * (m_texture_width / m_squareEdgeSize)); |
| |
| /* Calculate expected and rendered pixel color */ |
| float rendered_rgba[4] = { 0 }; |
| float expected_rgba[4]; |
| |
| for (unsigned int n_channel = 0; n_channel < 4 /* RGBA */; ++n_channel) |
| { |
| rendered_rgba[n_channel] = float(data[n_channel]) / 255.0f; |
| } |
| |
| expected_rgba[0] = (glw::GLfloat)(primitiveID % 64) / 64.0f; |
| expected_rgba[1] = deFloatFloor((glw::GLfloat)(primitiveID) / 64.0f) / 64.0f; |
| expected_rgba[2] = (glw::GLfloat)(primitiveID) / 4096.0f; |
| expected_rgba[3] = (((primitiveID % 2) == 0) ? 1.0f : 0.0f); |
| |
| /* Compare the data */ |
| if (de::abs(rendered_rgba[0] - expected_rgba[0]) > epsilon || |
| de::abs(rendered_rgba[1] - expected_rgba[1]) > epsilon || |
| de::abs(rendered_rgba[2] - expected_rgba[2]) > epsilon || |
| de::abs(rendered_rgba[3] - expected_rgba[3]) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Primitive ID: " << primitiveID << "Rendered data" |
| << "equal (" << rendered_rgba[0] << ", " << rendered_rgba[1] << ", " |
| << rendered_rgba[2] << ", " << rendered_rgba[3] << ") " |
| << "exceeds allowed epsilon when compared to expected data equal (" |
| << expected_rgba[0] << ", " << expected_rgba[1] << ", " << expected_rgba[2] << ", " |
| << expected_rgba[3] << ")." << tcu::TestLog::EndMessage; |
| |
| delete[] resultBuffer; |
| resultBuffer = NULL; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } /* if (rendered data is invalid) */ |
| } /* for (all columns) */ |
| } /* for (all rows) */ |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| |
| delete[] resultBuffer; |
| resultBuffer = NULL; |
| |
| return STOP; |
| } |
| |
| } // namespace glcts |
