1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2017 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ /*! 20 * \file glcSeparableProgramXFBTests.cpp 21 * \brief 22 */ /*-------------------------------------------------------------------*/ 23 24 #include "glcSeparableProgramsTransformFeedbackTests.hpp" 25 #include "glcViewportArrayTests.hpp" 26 #include "gluContextInfo.hpp" 27 #include "gluDefs.hpp" 28 #include "glwEnums.hpp" 29 #include "glwFunctions.hpp" 30 #include "tcuCommandLine.hpp" 31 #include "tcuStringTemplate.hpp" 32 #include "tcuTestLog.hpp" 33 34 using namespace tcu; 35 using namespace glu; 36 using namespace glw; 37 using namespace glcts::ViewportArray; 38 39 namespace glcts 40 { 41 42 /** 43 * @brief The StageIndex enum. Stages order coresponds to order 44 * in which shader sources are specified in Utils::program::build. 45 */ 46 enum StageIndex 47 { 48 FRAGMENT_STAGE_INDEX = 0, 49 GEOMETRY_STAGE_INDEX, 50 TESSELLATION_CONTROL_STAGE, 51 TESSELLATION_EVALUATION_STAGE, 52 VERTEX_STAGE, 53 STAGES_COUNT 54 }; 55 56 /** 57 * @brief The StageTokens array. Stages order coresponds to order 58 * in which shader sources are specified in Utils::program::build. 59 */ 60 static const GLenum StageTokens[STAGES_COUNT] = { GL_FRAGMENT_SHADER_BIT, GL_GEOMETRY_SHADER_BIT, 61 GL_TESS_CONTROL_SHADER_BIT, GL_TESS_EVALUATION_SHADER_BIT, 62 GL_VERTEX_SHADER_BIT }; 63 64 /** 65 * @brief The StageData structure. 66 */ 67 struct StageData 68 { 69 const GLchar* source; 70 const GLchar* const* tfVaryings; 71 const GLuint tfVaryingsCount; 72 }; 73 74 /** 75 * @brief The PerStageData structure containimg shader data per all stages. 76 */ 77 struct PerStageData 78 { 79 StageData stage[STAGES_COUNT]; 80 }; 81 82 static const GLchar* vs_code = "${VERSION}\n" 83 "flat out highp int o_vert;\n" 84 "${PERVERTEX_BLOCK}\n" 85 "void main()\n" 86 "{\n" 87 " o_vert = 1;\n" 88 " gl_Position = vec4(1, 0, 0, 1);\n" 89 "}\n"; 90 91 static const GLchar* vs_tf_varyings[] = { "o_vert" }; 92 93 static const GLchar* tcs_code = "${VERSION}\n" 94 "layout(vertices = 1) out;\n" 95 "flat in highp int o_vert[];\n" 96 "${PERVERTEX_BLOCK}\n" 97 "void main()\n" 98 "{\n" 99 " gl_TessLevelInner[0] = 1.0;\n" 100 " gl_TessLevelInner[1] = 1.0;\n" 101 " gl_TessLevelOuter[0] = 1.0;\n" 102 " gl_TessLevelOuter[1] = 1.0;\n" 103 " gl_TessLevelOuter[2] = 1.0;\n" 104 " gl_TessLevelOuter[3] = 1.0;\n" 105 "}\n"; 106 107 static const GLchar* tes_code = "${VERSION}\n" 108 "layout (triangles, point_mode) in;\n" 109 "flat out highp int o_tess;\n" 110 "${PERVERTEX_BLOCK}\n" 111 "void main()\n" 112 "{\n" 113 " o_tess = 2;\n" 114 " gl_Position = vec4(gl_TessCoord.xy*2.0 - 1.0, 0.0, 1.0);\n" 115 "}\n"; 116 117 static const GLchar* tes_tf_varyings[] = { "o_tess" }; 118 119 static const GLchar* gs_code = "${VERSION}\n" 120 "layout (points) in;\n" 121 "layout (points, max_vertices = 3) out;\n" 122 "${PERVERTEX_BLOCK}\n" 123 "flat in highp int ${IN_VARYING_NAME}[];\n" 124 "flat out highp int o_geom;\n" 125 "void main()\n" 126 "{\n" 127 " o_geom = 3;\n" 128 " gl_Position = vec4(-1, -1, 0, 1);\n" 129 " EmitVertex();\n" 130 " o_geom = 3;\n" 131 " gl_Position = vec4(-1, 1, 0, 1);\n" 132 " EmitVertex();\n" 133 " o_geom = 3;\n" 134 " gl_Position = vec4(1, -1, 0, 1);\n" 135 " EmitVertex();\n" 136 "}\n"; 137 138 static const GLchar* gs_tf_varyings[] = { "o_geom" }; 139 140 static const GLchar* fs_code = "${VERSION}\n" 141 "flat in highp int ${IN_VARYING_NAME};" 142 "out highp vec4 o_color;\n" 143 "void main()\n" 144 "{\n" 145 " o_color = vec4(1.0);\n" 146 "}\n"; 147 148 class SeparableProgramTFTestCase : public deqp::TestCase 149 { 150 public: 151 /* Public methods */ 152 SeparableProgramTFTestCase(deqp::Context& context, const char* name, PerStageData shaderData, GLint expectedValue); 153 154 tcu::TestNode::IterateResult iterate(void); 155 156 protected: 157 /* Protected attributes */ 158 PerStageData m_shaderData; 159 GLint m_expectedValue; 160 }; 161 162 /** Constructor. 163 * 164 * @param context Rendering context 165 * @param name Test name 166 * @param description Test description 167 */ 168 SeparableProgramTFTestCase::SeparableProgramTFTestCase(deqp::Context& context, const char* name, 169 PerStageData shaderData, GLint expectedValue) 170 : deqp::TestCase(context, name, ""), m_shaderData(shaderData), m_expectedValue(expectedValue) 171 { 172 } 173 174 tcu::TestNode::IterateResult SeparableProgramTFTestCase::iterate(void) 175 { 176 const Functions& gl = m_context.getRenderContext().getFunctions(); 177 ContextType contextType = m_context.getRenderContext().getType(); 178 GLSLVersion glslVersion = getContextTypeGLSLVersion(contextType); 179 180 /* For core GL gl_PerVertex interface block is combined from two parts. 181 * First part contains definition and the second part name, which is 182 * only specified for tess control stage (arrays are used here to avoid 183 * three branches in a loop). For ES both parts are empty string */ 184 const char* blockName[STAGES_COUNT] = { "", ";\n", " gl_out[];\n", ";\n", ";\n" }; 185 const char* blockEmptyName[STAGES_COUNT] = { "", "", "", "", "" }; 186 std::string vertexBlock(""); 187 const char** vertexBlockPostfix = blockEmptyName; 188 if (isContextTypeGLCore(contextType)) 189 { 190 vertexBlock = "out gl_PerVertex" 191 "{\n" 192 " vec4 gl_Position;\n" 193 "}"; 194 vertexBlockPostfix = blockName; 195 } 196 197 /* Construct specialization map - some specializations differ per stage */ 198 std::map<std::string, std::string> specializationMap; 199 specializationMap["VERSION"] = glu::getGLSLVersionDeclaration(glslVersion); 200 201 /* Create separate programs - start from vertex stage to catch varying names */ 202 std::vector<Utils::program> programs(STAGES_COUNT, Utils::program(m_context)); 203 const char* code[STAGES_COUNT] = { 0, 0, 0, 0, 0 }; 204 for (int stageIndex = VERTEX_STAGE; stageIndex > -1; --stageIndex) 205 { 206 StageData* stageData = m_shaderData.stage + stageIndex; 207 std::string source = stageData->source; 208 if (source.empty()) 209 continue; 210 specializationMap["PERVERTEX_BLOCK"] = vertexBlock + vertexBlockPostfix[stageIndex]; 211 std::string specializedShader = StringTemplate(source).specialize(specializationMap); 212 213 code[stageIndex] = specializedShader.c_str(); 214 programs[stageIndex].build(0, code[0], code[1], code[2], code[3], code[4], stageData->tfVaryings, 215 stageData->tfVaryingsCount, true); 216 code[stageIndex] = 0; 217 218 /* Use varying name from current stage to specialize next stage */ 219 if (stageData->tfVaryings) 220 specializationMap["IN_VARYING_NAME"] = stageData->tfVaryings[0]; 221 } 222 223 /* Create program pipeline */ 224 GLuint pipelineId; 225 gl.genProgramPipelines(1, &pipelineId); 226 gl.bindProgramPipeline(pipelineId); 227 for (int stageIndex = 0; stageIndex < STAGES_COUNT; ++stageIndex) 228 { 229 if (!programs[stageIndex].m_program_object_id) 230 continue; 231 gl.useProgramStages(pipelineId, StageTokens[stageIndex], programs[stageIndex].m_program_object_id); 232 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 233 } 234 235 /* Validate the pipeline */ 236 GLint validateStatus = GL_FALSE; 237 gl.validateProgramPipeline(pipelineId); 238 GLU_EXPECT_NO_ERROR(gl.getError(), "glValidateProgramPipeline() call failed."); 239 gl.getProgramPipelineiv(pipelineId, GL_VALIDATE_STATUS, &validateStatus); 240 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramPipelineiv() call failed."); 241 if (validateStatus != GL_TRUE) 242 { 243 GLint logLength; 244 gl.getProgramPipelineiv(pipelineId, GL_INFO_LOG_LENGTH, &logLength); 245 if (logLength) 246 { 247 std::vector<GLchar> logBuffer(logLength + 1); 248 gl.getProgramPipelineInfoLog(pipelineId, logLength + 1, NULL, &logBuffer[0]); 249 m_context.getTestContext().getLog() << tcu::TestLog::Message << &logBuffer[0] << tcu::TestLog::EndMessage; 250 } 251 TCU_FAIL("Program pipeline has not been validated successfully."); 252 } 253 254 /* Generate buffer object to hold result XFB data */ 255 Utils::buffer tfb(m_context); 256 GLsizeiptr tfbSize = 100; 257 tfb.generate(GL_TRANSFORM_FEEDBACK_BUFFER); 258 tfb.update(tfbSize, 0 /* data */, GL_DYNAMIC_COPY); 259 tfb.bindRange(0, 0, tfbSize); 260 261 /* Generate VAO to use for the draw calls */ 262 Utils::vertexArray vao(m_context); 263 vao.generate(); 264 vao.bind(); 265 266 /* Generate query object */ 267 GLuint queryId; 268 gl.genQueries(1, &queryId); 269 270 /* Check if tessellation stage is active */ 271 GLenum drawMode = GL_POINTS; 272 if (strlen(m_shaderData.stage[TESSELLATION_CONTROL_STAGE].source) > 0) 273 drawMode = GL_PATCHES; 274 275 /* Draw and capture data */ 276 gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queryId); 277 gl.beginTransformFeedback(GL_POINTS); 278 gl.patchParameteri(GL_PATCH_VERTICES, 1); 279 gl.drawArrays(drawMode, 0 /* first */, 1 /* count */); 280 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 281 gl.endTransformFeedback(); 282 gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); 283 284 /* Get TF results */ 285 GLuint writtenPrimitives = 0; 286 gl.getQueryObjectuiv(queryId, GL_QUERY_RESULT, &writtenPrimitives); 287 GLint* feedbackData = (GLint*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfbSize, GL_MAP_READ_BIT); 288 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer"); 289 290 /* Verify if only values from upstream shader were captured */ 291 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 292 if (writtenPrimitives != 0) 293 { 294 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 295 for (GLuint dataIndex = 0; dataIndex < writtenPrimitives; ++dataIndex) 296 { 297 if (feedbackData[dataIndex] == m_expectedValue) 298 continue; 299 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 300 break; 301 } 302 } 303 304 /* Cleanup */ 305 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 306 gl.deleteQueries(1, &queryId); 307 gl.bindProgramPipeline(0); 308 gl.deleteProgramPipelines(1, &pipelineId); 309 310 return STOP; 311 } 312 313 /** Constructor. 314 * 315 * @param context Rendering context. 316 */ 317 SeparableProgramsTransformFeedbackTests::SeparableProgramsTransformFeedbackTests(deqp::Context& context) 318 : deqp::TestCaseGroup(context, "separable_programs_tf", "") 319 { 320 } 321 322 /** Initializes the test group contents. */ 323 void SeparableProgramsTransformFeedbackTests::init(void) 324 { 325 PerStageData tessellation_active = { { 326 { fs_code, NULL, 0 }, // fragment stage 327 { "", NULL, 0 }, // geometry stage 328 { tcs_code, NULL, 0 }, // tesselation control stage 329 { tes_code, tes_tf_varyings, 1 }, // tesselation evaluation stage 330 { vs_code, vs_tf_varyings, 1 } // vertex_stage 331 } }; 332 PerStageData geometry_active = { { 333 { fs_code, NULL, 0 }, // fragment stage 334 { gs_code, gs_tf_varyings, 1 }, // geometry stage 335 { tcs_code, NULL, 0 }, // tesselation control stage 336 { tes_code, tes_tf_varyings, 1 }, // tesselation evaluation stage 337 { vs_code, vs_tf_varyings, 1 } // vertex_stage 338 } }; 339 340 addChild(new SeparableProgramTFTestCase(m_context, "tessellation_active", tessellation_active, 2)); 341 addChild(new SeparableProgramTFTestCase(m_context, "geometry_active", geometry_active, 3)); 342 } 343 344 } /* glcts namespace */ 345
