--- /dev/null
+/*-------------------------------------------------------------------------
+ * OpenGL Conformance Test Suite
+ * -----------------------------
+ *
+ * Copyright (c) 2017 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 glcSeparableProgramXFBTests.cpp
+ * \brief
+ */ /*-------------------------------------------------------------------*/
+
+#include "glcSeparableProgramsTransformFeedbackTests.hpp"
+#include "glcViewportArrayTests.hpp"
+#include "gluContextInfo.hpp"
+#include "gluDefs.hpp"
+#include "glwEnums.hpp"
+#include "glwFunctions.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuStringTemplate.hpp"
+#include "tcuTestLog.hpp"
+
+using namespace tcu;
+using namespace glu;
+using namespace glw;
+using namespace glcts::ViewportArray;
+
+namespace glcts
+{
+
+/**
+ * @brief The StageIndex enum. Stages order coresponds to order
+ * in which shader sources are specified in Utils::program::build.
+ */
+enum StageIndex
+{
+ FRAGMENT_STAGE_INDEX = 0,
+ GEOMETRY_STAGE_INDEX,
+ TESSELLATION_CONTROL_STAGE,
+ TESSELLATION_EVALUATION_STAGE,
+ VERTEX_STAGE,
+ STAGES_COUNT
+};
+
+/**
+ * @brief The StageTokens array. Stages order coresponds to order
+ * in which shader sources are specified in Utils::program::build.
+ */
+static const GLenum StageTokens[STAGES_COUNT] = { GL_FRAGMENT_SHADER_BIT, GL_GEOMETRY_SHADER_BIT,
+ GL_TESS_CONTROL_SHADER_BIT, GL_TESS_EVALUATION_SHADER_BIT,
+ GL_VERTEX_SHADER_BIT };
+
+/**
+ * @brief The StageData structure.
+ */
+struct StageData
+{
+ const GLchar* source;
+ const GLchar* const* tfVaryings;
+ const GLuint tfVaryingsCount;
+};
+
+/**
+ * @brief The PerStageData structure containimg shader data per all stages.
+ */
+struct PerStageData
+{
+ StageData stage[STAGES_COUNT];
+};
+
+static const GLchar* vs_code = "${VERSION}\n"
+ "flat out highp int o_vert;\n"
+ "${PERVERTEX_BLOCK}\n"
+ "void main()\n"
+ "{\n"
+ " o_vert = 1;\n"
+ " gl_Position = vec4(1, 0, 0, 1);\n"
+ "}\n";
+
+static const GLchar* vs_tf_varyings[] = { "o_vert" };
+
+static const GLchar* tcs_code = "${VERSION}\n"
+ "layout(vertices = 1) out;\n"
+ "flat in highp int o_vert[];\n"
+ "${PERVERTEX_BLOCK}\n"
+ "void main()\n"
+ "{\n"
+ " gl_TessLevelInner[0] = 1.0;\n"
+ " gl_TessLevelInner[1] = 1.0;\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"
+ "}\n";
+
+static const GLchar* tes_code = "${VERSION}\n"
+ "layout (triangles, point_mode) in;\n"
+ "flat out highp int o_tess;\n"
+ "${PERVERTEX_BLOCK}\n"
+ "void main()\n"
+ "{\n"
+ " o_tess = 2;\n"
+ " gl_Position = vec4(gl_TessCoord.xy*2.0 - 1.0, 0.0, 1.0);\n"
+ "}\n";
+
+static const GLchar* tes_tf_varyings[] = { "o_tess" };
+
+static const GLchar* gs_code = "${VERSION}\n"
+ "layout (points) in;\n"
+ "layout (points, max_vertices = 3) out;\n"
+ "${PERVERTEX_BLOCK}\n"
+ "flat in highp int ${IN_VARYING_NAME}[];\n"
+ "flat out highp int o_geom;\n"
+ "void main()\n"
+ "{\n"
+ " o_geom = 3;\n"
+ " gl_Position = vec4(-1, -1, 0, 1);\n"
+ " EmitVertex();\n"
+ " o_geom = 3;\n"
+ " gl_Position = vec4(-1, 1, 0, 1);\n"
+ " EmitVertex();\n"
+ " o_geom = 3;\n"
+ " gl_Position = vec4(1, -1, 0, 1);\n"
+ " EmitVertex();\n"
+ "}\n";
+
+static const GLchar* gs_tf_varyings[] = { "o_geom" };
+
+static const GLchar* fs_code = "${VERSION}\n"
+ "flat in highp int ${IN_VARYING_NAME};"
+ "out highp vec4 o_color;\n"
+ "void main()\n"
+ "{\n"
+ " o_color = vec4(1.0);\n"
+ "}\n";
+
+class SeparableProgramTFTestCase : public deqp::TestCase
+{
+public:
+ /* Public methods */
+ SeparableProgramTFTestCase(deqp::Context& context, const char* name, PerStageData shaderData, GLint expectedValue);
+
+ tcu::TestNode::IterateResult iterate(void);
+
+protected:
+ /* Protected attributes */
+ PerStageData m_shaderData;
+ GLint m_expectedValue;
+};
+
+/** Constructor.
+ *
+ * @param context Rendering context
+ * @param name Test name
+ * @param description Test description
+ */
+SeparableProgramTFTestCase::SeparableProgramTFTestCase(deqp::Context& context, const char* name,
+ PerStageData shaderData, GLint expectedValue)
+ : deqp::TestCase(context, name, ""), m_shaderData(shaderData), m_expectedValue(expectedValue)
+{
+}
+
+tcu::TestNode::IterateResult SeparableProgramTFTestCase::iterate(void)
+{
+ const Functions& gl = m_context.getRenderContext().getFunctions();
+ ContextType contextType = m_context.getRenderContext().getType();
+ GLSLVersion glslVersion = getContextTypeGLSLVersion(contextType);
+
+ /* For core GL gl_PerVertex interface block is combined from two parts.
+ * First part contains definition and the second part name, which is
+ * only specified for tess control stage (arrays are used here to avoid
+ * three branches in a loop). For ES both parts are empty string */
+ const char* blockName[STAGES_COUNT] = { "", ";\n", " gl_out[];\n", ";\n", ";\n" };
+ const char* blockEmptyName[STAGES_COUNT] = { "", "", "", "", "" };
+ std::string vertexBlock("");
+ const char** vertexBlockPostfix = blockEmptyName;
+ if (isContextTypeGLCore(contextType))
+ {
+ vertexBlock = "out gl_PerVertex"
+ "{\n"
+ " vec4 gl_Position;\n"
+ "}";
+ vertexBlockPostfix = blockName;
+ }
+
+ /* Construct specialization map - some specializations differ per stage */
+ std::map<std::string, std::string> specializationMap;
+ specializationMap["VERSION"] = glu::getGLSLVersionDeclaration(glslVersion);
+
+ /* Create separate programs - start from vertex stage to catch varying names */
+ std::vector<Utils::program> programs(STAGES_COUNT, Utils::program(m_context));
+ const char* code[STAGES_COUNT] = { 0, 0, 0, 0, 0 };
+ for (int stageIndex = VERTEX_STAGE; stageIndex > -1; --stageIndex)
+ {
+ StageData* stageData = m_shaderData.stage + stageIndex;
+ std::string source = stageData->source;
+ if (source.empty())
+ continue;
+ specializationMap["PERVERTEX_BLOCK"] = vertexBlock + vertexBlockPostfix[stageIndex];
+ std::string specializedShader = StringTemplate(source).specialize(specializationMap);
+
+ code[stageIndex] = specializedShader.c_str();
+ programs[stageIndex].build(0, code[0], code[1], code[2], code[3], code[4], stageData->tfVaryings,
+ stageData->tfVaryingsCount, true);
+ code[stageIndex] = 0;
+
+ /* Use varying name from current stage to specialize next stage */
+ if (stageData->tfVaryings)
+ specializationMap["IN_VARYING_NAME"] = stageData->tfVaryings[0];
+ }
+
+ /* Create program pipeline */
+ GLuint pipelineId;
+ gl.genProgramPipelines(1, &pipelineId);
+ gl.bindProgramPipeline(pipelineId);
+ for (int stageIndex = 0; stageIndex < STAGES_COUNT; ++stageIndex)
+ {
+ if (!programs[stageIndex].m_program_object_id)
+ continue;
+ gl.useProgramStages(pipelineId, StageTokens[stageIndex], programs[stageIndex].m_program_object_id);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed.");
+ }
+
+ /* Validate the pipeline */
+ GLint validateStatus = GL_FALSE;
+ gl.validateProgramPipeline(pipelineId);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glValidateProgramPipeline() call failed.");
+ gl.getProgramPipelineiv(pipelineId, GL_VALIDATE_STATUS, &validateStatus);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramPipelineiv() call failed.");
+ if (validateStatus != GL_TRUE)
+ {
+ GLint logLength;
+ gl.getProgramPipelineiv(pipelineId, GL_INFO_LOG_LENGTH, &logLength);
+ if (logLength)
+ {
+ std::vector<GLchar> logBuffer(logLength + 1);
+ gl.getProgramPipelineInfoLog(pipelineId, logLength + 1, NULL, &logBuffer[0]);
+ m_context.getTestContext().getLog() << tcu::TestLog::Message << &logBuffer[0] << tcu::TestLog::EndMessage;
+ }
+ TCU_FAIL("Program pipeline has not been validated successfully.");
+ }
+
+ /* Generate buffer object to hold result XFB data */
+ Utils::buffer tfb(m_context);
+ GLsizeiptr tfbSize = 100;
+ tfb.generate(GL_TRANSFORM_FEEDBACK_BUFFER);
+ tfb.update(tfbSize, 0 /* data */, GL_DYNAMIC_COPY);
+ tfb.bindRange(0, 0, tfbSize);
+
+ /* Generate VAO to use for the draw calls */
+ Utils::vertexArray vao(m_context);
+ vao.generate();
+ vao.bind();
+
+ /* Generate query object */
+ GLuint queryId;
+ gl.genQueries(1, &queryId);
+
+ /* Check if tessellation stage is active */
+ GLenum drawMode = GL_POINTS;
+ if (strlen(m_shaderData.stage[TESSELLATION_CONTROL_STAGE].source) > 0)
+ drawMode = GL_PATCHES;
+
+ /* Draw and capture data */
+ gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queryId);
+ gl.beginTransformFeedback(GL_POINTS);
+ gl.patchParameteri(GL_PATCH_VERTICES, 1);
+ gl.drawArrays(drawMode, 0 /* first */, 1 /* count */);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
+ gl.endTransformFeedback();
+ gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+
+ /* Get TF results */
+ GLuint writtenPrimitives = 0;
+ gl.getQueryObjectuiv(queryId, GL_QUERY_RESULT, &writtenPrimitives);
+ GLint* feedbackData = (GLint*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfbSize, GL_MAP_READ_BIT);
+ GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer");
+
+ /* Verify if only values from upstream shader were captured */
+ m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
+ if (writtenPrimitives != 0)
+ {
+ m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
+ for (GLuint dataIndex = 0; dataIndex < writtenPrimitives; ++dataIndex)
+ {
+ if (feedbackData[dataIndex] == m_expectedValue)
+ continue;
+ m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
+ break;
+ }
+ }
+
+ /* Cleanup */
+ gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
+ gl.deleteQueries(1, &queryId);
+ gl.bindProgramPipeline(0);
+ gl.deleteProgramPipelines(1, &pipelineId);
+
+ return STOP;
+}
+
+/** Constructor.
+ *
+ * @param context Rendering context.
+ */
+SeparableProgramsTransformFeedbackTests::SeparableProgramsTransformFeedbackTests(deqp::Context& context)
+ : deqp::TestCaseGroup(context, "separable_programs_tf", "")
+{
+}
+
+/** Initializes the test group contents. */
+void SeparableProgramsTransformFeedbackTests::init(void)
+{
+ PerStageData tessellation_active = { {
+ { fs_code, NULL, 0 }, // fragment stage
+ { "", NULL, 0 }, // geometry stage
+ { tcs_code, NULL, 0 }, // tesselation control stage
+ { tes_code, tes_tf_varyings, 1 }, // tesselation evaluation stage
+ { vs_code, vs_tf_varyings, 1 } // vertex_stage
+ } };
+ PerStageData geometry_active = { {
+ { fs_code, NULL, 0 }, // fragment stage
+ { gs_code, gs_tf_varyings, 1 }, // geometry stage
+ { tcs_code, NULL, 0 }, // tesselation control stage
+ { tes_code, tes_tf_varyings, 1 }, // tesselation evaluation stage
+ { vs_code, vs_tf_varyings, 1 } // vertex_stage
+ } };
+
+ addChild(new SeparableProgramTFTestCase(m_context, "tessellation_active", tessellation_active, 2));
+ addChild(new SeparableProgramTFTestCase(m_context, "geometry_active", geometry_active, 3));
+}
+
+} /* glcts namespace */
projects / platform / upstream / VK-GL-CTS.git / commitdiff