1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2015 The Android Open Source Project 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 21 * \brief Program State Query tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fProgramStateQueryTests.hpp" 25 #include "es31fInfoLogQueryShared.hpp" 26 #include "glsStateQueryUtil.hpp" 27 #include "gluRenderContext.hpp" 28 #include "gluCallLogWrapper.hpp" 29 #include "gluContextInfo.hpp" 30 #include "gluObjectWrapper.hpp" 31 #include "gluShaderProgram.hpp" 32 #include "glwFunctions.hpp" 33 #include "glwEnums.hpp" 34 #include "tcuStringTemplate.hpp" 35 36 namespace deqp 37 { 38 39 using std::string; 40 using std::map; 41 42 namespace gles31 43 { 44 namespace Functional 45 { 46 namespace 47 { 48 49 using namespace gls::StateQueryUtil; 50 51 static const char* getVerifierSuffix (QueryType type) 52 { 53 switch (type) 54 { 55 case QUERY_PROGRAM_INTEGER_VEC3: 56 case QUERY_PROGRAM_INTEGER: 57 return "get_programiv"; 58 59 default: 60 DE_ASSERT(DE_FALSE); 61 return DE_NULL; 62 } 63 } 64 65 static std::string specializeShader(Context& context, const char* code) 66 { 67 const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(context.getRenderContext().getType()); 68 std::map<std::string, std::string> specializationMap; 69 70 specializationMap["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glslVersion); 71 72 if (glu::contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 73 { 74 specializationMap["GEOMETRY_SHADER_REQUIRE"] = ""; 75 specializationMap["TESSELLATION_SHADER_REQUIRE"] = ""; 76 } 77 else 78 { 79 specializationMap["GEOMETRY_SHADER_REQUIRE"] = "#extension GL_EXT_geometry_shader : require"; 80 specializationMap["TESSELLATION_SHADER_REQUIRE"] = "#extension GL_EXT_tessellation_shader : require"; 81 } 82 83 return tcu::StringTemplate(code).specialize(specializationMap); 84 } 85 86 87 class GeometryShaderCase : public TestCase 88 { 89 public: 90 GeometryShaderCase (Context& context, QueryType verifier, const char* name, const char* desc); 91 IterateResult iterate (void); 92 93 private: 94 const QueryType m_verifier; 95 }; 96 97 GeometryShaderCase::GeometryShaderCase (Context& context, QueryType verifier, const char* name, const char* desc) 98 : TestCase (context, name, desc) 99 , m_verifier (verifier) 100 { 101 } 102 103 GeometryShaderCase::IterateResult GeometryShaderCase::iterate (void) 104 { 105 const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)); 106 107 if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) 108 TCU_THROW(NotSupportedError, "Geometry shader tests require GL_EXT_geometry_shader extension or an OpenGL ES 3.2 or higher context."); 109 110 111 static const char* const s_vtxFragTemplate = "${GLSL_VERSION_DECL}\n" 112 "void main()\n" 113 "{\n" 114 "}\n"; 115 116 static const char* const s_geometryTemplate1 = "${GLSL_VERSION_DECL}\n" 117 "${GEOMETRY_SHADER_REQUIRE}\n" 118 "layout(triangles) in;" 119 "layout(triangle_strip, max_vertices = 3) out;\n" 120 "void main()\n" 121 "{\n" 122 " EndPrimitive();\n" 123 "}\n"; 124 125 static const char* const s_geometryTemplate2 = "${GLSL_VERSION_DECL}\n" 126 "${GEOMETRY_SHADER_REQUIRE}\n" 127 "layout(points) in;" 128 "layout(line_strip, max_vertices = 5) out;\n" 129 "void main()\n" 130 "{\n" 131 " EndPrimitive();\n" 132 "}\n"; 133 134 static const char* const s_geometryTemplate3 = "${GLSL_VERSION_DECL}\n" 135 "${GEOMETRY_SHADER_REQUIRE}\n" 136 "layout(points) in;" 137 "layout(points, max_vertices = 50) out;\n" 138 "void main()\n" 139 "{\n" 140 " EndPrimitive();\n" 141 "}\n"; 142 143 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 144 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 145 146 gl.enableLogging(true); 147 148 { 149 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Layout", "triangles in, triangle strip out, 3 vertices"); 150 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() 151 << glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate)) 152 << glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate)) 153 << glu::GeometrySource(specializeShader(m_context, s_geometryTemplate1))); 154 155 TCU_CHECK_MSG(program.isOk(), "Compile failed"); 156 157 m_testCtx.getLog() << program; 158 159 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_VERTICES_OUT, 3, m_verifier); 160 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_INPUT_TYPE, GL_TRIANGLES, m_verifier); 161 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_OUTPUT_TYPE, GL_TRIANGLE_STRIP, m_verifier); 162 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_SHADER_INVOCATIONS, 1, m_verifier); 163 } 164 165 { 166 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Layout", "points in, line strip out, 5 vertices"); 167 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() 168 << glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate)) 169 << glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate)) 170 << glu::GeometrySource(specializeShader(m_context, s_geometryTemplate2))); 171 172 TCU_CHECK_MSG(program.isOk(), "Compile failed"); 173 174 m_testCtx.getLog() << program; 175 176 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_VERTICES_OUT, 5, m_verifier); 177 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_INPUT_TYPE, GL_POINTS, m_verifier); 178 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_OUTPUT_TYPE, GL_LINE_STRIP, m_verifier); 179 } 180 181 { 182 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Layout", "points in, points out, 50 vertices"); 183 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() 184 << glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate)) 185 << glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate)) 186 << glu::GeometrySource(specializeShader(m_context, s_geometryTemplate3))); 187 188 TCU_CHECK_MSG(program.isOk(), "Compile failed"); 189 190 m_testCtx.getLog() << program; 191 192 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_VERTICES_OUT, 50, m_verifier); 193 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_INPUT_TYPE, GL_POINTS, m_verifier); 194 verifyStateProgramInteger(result, gl, program.getProgram(), GL_GEOMETRY_OUTPUT_TYPE, GL_POINTS, m_verifier); 195 } 196 197 result.setTestContextResult(m_testCtx); 198 return STOP; 199 } 200 201 class TessellationShaderCase : public TestCase 202 { 203 public: 204 TessellationShaderCase (Context& context, QueryType verifier, const char* name, const char* desc); 205 IterateResult iterate (void); 206 207 private: 208 const QueryType m_verifier; 209 }; 210 211 TessellationShaderCase::TessellationShaderCase (Context& context, QueryType verifier, const char* name, const char* desc) 212 : TestCase (context, name, desc) 213 , m_verifier (verifier) 214 { 215 } 216 217 TessellationShaderCase::IterateResult TessellationShaderCase::iterate (void) 218 { 219 const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)); 220 221 if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader")) 222 TCU_THROW(NotSupportedError, "Tessellation shader tests require GL_EXT_tessellation_shader extension or an OpenGL ES 3.2 or higher context."); 223 224 225 static const char* const s_vtxFragTemplate = "${GLSL_VERSION_DECL}\n" 226 "void main()\n" 227 "{\n" 228 "}\n"; 229 230 static const char* const s_tessCtrlTemplate1 = "${GLSL_VERSION_DECL}\n" 231 "${TESSELLATION_SHADER_REQUIRE}\n" 232 "layout(vertices = 3) out;\n" 233 "void main()\n" 234 "{\n" 235 "}\n"; 236 237 static const char* const s_tessEvalTemplate1 = "${GLSL_VERSION_DECL}\n" 238 "${TESSELLATION_SHADER_REQUIRE}\n" 239 "layout(triangles, equal_spacing, cw) in;\n" 240 "void main()\n" 241 "{\n" 242 "}\n"; 243 244 static const char* const s_tessCtrlTemplate2 = "${GLSL_VERSION_DECL}\n" 245 "${TESSELLATION_SHADER_REQUIRE}\n" 246 "layout(vertices = 5) out;\n" 247 "void main()\n" 248 "{\n" 249 "}\n"; 250 251 static const char* const s_tessEvalTemplate2 = "${GLSL_VERSION_DECL}\n" 252 "${TESSELLATION_SHADER_REQUIRE}\n" 253 "layout(quads, fractional_even_spacing, ccw) in;\n" 254 "void main()\n" 255 "{\n" 256 "}\n"; 257 258 static const char* const s_tessEvalTemplate3 = "${GLSL_VERSION_DECL}\n" 259 "${TESSELLATION_SHADER_REQUIRE}\n" 260 "layout(isolines, fractional_odd_spacing, ccw, point_mode) in;\n" 261 "void main()\n" 262 "{\n" 263 "}\n"; 264 265 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 266 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 267 268 gl.enableLogging(true); 269 270 { 271 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Query State", "3 vertices, triangles, equal_spacing, cw"); 272 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() 273 << glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate)) 274 << glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate)) 275 << glu::TessellationControlSource(specializeShader(m_context, s_tessCtrlTemplate1)) 276 << glu::TessellationEvaluationSource(specializeShader(m_context, s_tessEvalTemplate1))); 277 278 TCU_CHECK_MSG(program.isOk(), "Compile failed"); 279 280 m_testCtx.getLog() << program; 281 282 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_CONTROL_OUTPUT_VERTICES, 3, m_verifier); 283 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_MODE, GL_TRIANGLES, m_verifier); 284 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_SPACING, GL_EQUAL, m_verifier); 285 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_VERTEX_ORDER, GL_CW, m_verifier); 286 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_POINT_MODE, GL_FALSE, m_verifier); 287 } 288 289 { 290 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Query State", "5 vertices, quads, fractional_even_spacing, ccw"); 291 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() 292 << glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate)) 293 << glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate)) 294 << glu::TessellationControlSource(specializeShader(m_context, s_tessCtrlTemplate2)) 295 << glu::TessellationEvaluationSource(specializeShader(m_context, s_tessEvalTemplate2))); 296 297 TCU_CHECK_MSG(program.isOk(), "Compile failed"); 298 299 m_testCtx.getLog() << program; 300 301 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_CONTROL_OUTPUT_VERTICES, 5, m_verifier); 302 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_MODE, GL_QUADS, m_verifier); 303 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_SPACING, GL_FRACTIONAL_EVEN, m_verifier); 304 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_VERTEX_ORDER, GL_CCW, m_verifier); 305 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_POINT_MODE, GL_FALSE, m_verifier); 306 } 307 308 { 309 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Query State", "5 vertices, isolines, fractional_odd_spacing, ccw, point_mode"); 310 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() 311 << glu::VertexSource(specializeShader(m_context, s_vtxFragTemplate)) 312 << glu::FragmentSource(specializeShader(m_context, s_vtxFragTemplate)) 313 << glu::TessellationControlSource(specializeShader(m_context, s_tessCtrlTemplate2)) 314 << glu::TessellationEvaluationSource(specializeShader(m_context, s_tessEvalTemplate3))); 315 316 TCU_CHECK_MSG(program.isOk(), "Compile failed"); 317 318 m_testCtx.getLog() << program; 319 320 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_CONTROL_OUTPUT_VERTICES, 5, m_verifier); 321 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_MODE, GL_ISOLINES, m_verifier); 322 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_SPACING, GL_FRACTIONAL_ODD, m_verifier); 323 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_VERTEX_ORDER, GL_CCW, m_verifier); 324 verifyStateProgramInteger(result, gl, program.getProgram(), GL_TESS_GEN_POINT_MODE, GL_TRUE, m_verifier); 325 } 326 327 result.setTestContextResult(m_testCtx); 328 return STOP; 329 } 330 331 class ProgramSeparableCase : public TestCase 332 { 333 public: 334 ProgramSeparableCase (Context& context, QueryType verifier, const char* name, const char* desc); 335 IterateResult iterate (void); 336 337 private: 338 const QueryType m_verifier; 339 }; 340 341 ProgramSeparableCase::ProgramSeparableCase (Context& context, QueryType verifier, const char* name, const char* desc) 342 : TestCase (context, name, desc) 343 , m_verifier (verifier) 344 { 345 } 346 347 ProgramSeparableCase::IterateResult ProgramSeparableCase::iterate (void) 348 { 349 const string vtxTemplate = "${GLSL_VERSION_DECL}\n" 350 "out highp vec4 v_color;\n" 351 "void main()\n" 352 "{\n" 353 " gl_Position = vec4(float(gl_VertexID) * 0.5, float(gl_VertexID+1) * 0.5, 0.0, 1.0);\n" 354 " v_color = vec4(float(gl_VertexID), 1.0, 0.0, 1.0);\n" 355 "}\n"; 356 const string fragTemplate = "${GLSL_VERSION_DECL}\n" 357 "in highp vec4 v_color;\n" 358 "layout(location=0) out highp vec4 o_color;\n" 359 "void main()\n" 360 "{\n" 361 " o_color = v_color;\n" 362 "}\n"; 363 364 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 365 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 366 glu::Shader vtxShader (m_context.getRenderContext(), glu::SHADERTYPE_VERTEX); 367 glu::Shader frgShader (m_context.getRenderContext(), glu::SHADERTYPE_FRAGMENT); 368 369 const std::string vStr = specializeShader(m_context, vtxTemplate.c_str()); 370 const std::string fStr = specializeShader(m_context, fragTemplate.c_str()); 371 const char* const vtxSourcePtr = vStr.c_str(); 372 const char* const fragSourcePtr = fStr.c_str(); 373 374 vtxShader.setSources(1, &vtxSourcePtr, DE_NULL); 375 frgShader.setSources(1, &fragSourcePtr, DE_NULL); 376 377 vtxShader.compile(); 378 frgShader.compile(); 379 380 { 381 const tcu::ScopedLogSection section(m_testCtx.getLog(), "VtxShader", "Vertex shader"); 382 m_testCtx.getLog() << vtxShader; 383 } 384 385 { 386 const tcu::ScopedLogSection section(m_testCtx.getLog(), "FrgShader", "Fragment shader"); 387 m_testCtx.getLog() << frgShader; 388 } 389 390 TCU_CHECK_MSG(vtxShader.getCompileStatus() && frgShader.getCompileStatus(), "failed to build shaders"); 391 392 gl.enableLogging(true); 393 394 { 395 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Initial", "Initial"); 396 glu::Program program (m_context.getRenderContext()); 397 398 verifyStateProgramInteger(result, gl, program.getProgram(), GL_PROGRAM_SEPARABLE, 0, m_verifier); 399 } 400 401 { 402 const tcu::ScopedLogSection section (m_testCtx.getLog(), "SetFalse", "SetFalse"); 403 glu::Program program (m_context.getRenderContext()); 404 int linkStatus = 0; 405 406 gl.glAttachShader(program.getProgram(), vtxShader.getShader()); 407 gl.glAttachShader(program.getProgram(), frgShader.getShader()); 408 gl.glProgramParameteri(program.getProgram(), GL_PROGRAM_SEPARABLE, GL_FALSE); 409 gl.glLinkProgram(program.getProgram()); 410 GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup program"); 411 412 gl.glGetProgramiv(program.getProgram(), GL_LINK_STATUS, &linkStatus); 413 GLU_EXPECT_NO_ERROR(gl.glGetError(), "query link status"); 414 415 TCU_CHECK_MSG(linkStatus == GL_TRUE, "failed to link program"); 416 417 verifyStateProgramInteger(result, gl, program.getProgram(), GL_PROGRAM_SEPARABLE, 0, m_verifier); 418 } 419 420 { 421 const tcu::ScopedLogSection section (m_testCtx.getLog(), "SetTrue", "SetTrue"); 422 glu::Program program (m_context.getRenderContext()); 423 int linkStatus = 0; 424 425 gl.glAttachShader(program.getProgram(), vtxShader.getShader()); 426 gl.glAttachShader(program.getProgram(), frgShader.getShader()); 427 gl.glProgramParameteri(program.getProgram(), GL_PROGRAM_SEPARABLE, GL_TRUE); 428 gl.glLinkProgram(program.getProgram()); 429 GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup program"); 430 431 gl.glGetProgramiv(program.getProgram(), GL_LINK_STATUS, &linkStatus); 432 GLU_EXPECT_NO_ERROR(gl.glGetError(), "query link status"); 433 434 TCU_CHECK_MSG(linkStatus == GL_TRUE, "failed to link program"); 435 436 verifyStateProgramInteger(result, gl, program.getProgram(), GL_PROGRAM_SEPARABLE, GL_TRUE, m_verifier); 437 } 438 439 result.setTestContextResult(m_testCtx); 440 return STOP; 441 } 442 443 class ComputeWorkGroupSizeCase : public TestCase 444 { 445 public: 446 ComputeWorkGroupSizeCase (Context& context, QueryType verifier, const char* name, const char* desc); 447 IterateResult iterate (void); 448 449 private: 450 const QueryType m_verifier; 451 }; 452 453 ComputeWorkGroupSizeCase::ComputeWorkGroupSizeCase (Context& context, QueryType verifier, const char* name, const char* desc) 454 : TestCase (context, name, desc) 455 , m_verifier (verifier) 456 { 457 } 458 459 ComputeWorkGroupSizeCase::IterateResult ComputeWorkGroupSizeCase::iterate (void) 460 { 461 static const char* const s_computeTemplate1D = "${GLSL_VERSION_DECL}\n" 462 "layout (local_size_x = 3) in;\n" 463 "layout(binding = 0) buffer Output\n" 464 "{\n" 465 " highp float val;\n" 466 "} sb_out;\n" 467 "\n" 468 "void main (void)\n" 469 "{\n" 470 " sb_out.val = 1.0;\n" 471 "}\n"; 472 static const char* const s_computeTemplate2D = "${GLSL_VERSION_DECL}\n" 473 "layout (local_size_x = 3, local_size_y = 2) in;\n" 474 "layout(binding = 0) buffer Output\n" 475 "{\n" 476 " highp float val;\n" 477 "} sb_out;\n" 478 "\n" 479 "void main (void)\n" 480 "{\n" 481 " sb_out.val = 1.0;\n" 482 "}\n"; 483 static const char* const s_computeTemplate3D = "${GLSL_VERSION_DECL}\n" 484 "layout (local_size_x = 3, local_size_y = 2, local_size_z = 4) in;\n" 485 "layout(binding = 0) buffer Output\n" 486 "{\n" 487 " highp float val;\n" 488 "} sb_out;\n" 489 "\n" 490 "void main (void)\n" 491 "{\n" 492 " sb_out.val = 1.0;\n" 493 "}\n"; 494 495 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 496 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 497 498 gl.enableLogging(true); 499 500 { 501 const tcu::ScopedLogSection section (m_testCtx.getLog(), "OneDimensional", "1D"); 502 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate1D))); 503 504 m_testCtx.getLog() << program; 505 506 TCU_CHECK_MSG(program.isOk(), "failed to build program"); 507 508 verifyStateProgramIntegerVec3(result, gl, program.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(3, 1, 1), m_verifier); 509 } 510 511 { 512 const tcu::ScopedLogSection section (m_testCtx.getLog(), "TwoDimensional", "2D"); 513 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate2D))); 514 515 m_testCtx.getLog() << program; 516 517 TCU_CHECK_MSG(program.isOk(), "failed to build program"); 518 519 verifyStateProgramIntegerVec3(result, gl, program.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(3, 2, 1), m_verifier); 520 } 521 522 { 523 const tcu::ScopedLogSection section (m_testCtx.getLog(), "TreeDimensional", "3D"); 524 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate3D))); 525 526 m_testCtx.getLog() << program; 527 528 TCU_CHECK_MSG(program.isOk(), "failed to build program"); 529 530 verifyStateProgramIntegerVec3(result, gl, program.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(3, 2, 4), m_verifier); 531 } 532 533 result.setTestContextResult(m_testCtx); 534 return STOP; 535 } 536 537 class ActiveAtomicCounterBuffersCase : public TestCase 538 { 539 public: 540 ActiveAtomicCounterBuffersCase (Context& context, QueryType verifier, const char* name, const char* desc); 541 IterateResult iterate (void); 542 543 private: 544 const QueryType m_verifier; 545 }; 546 547 ActiveAtomicCounterBuffersCase::ActiveAtomicCounterBuffersCase (Context& context, QueryType verifier, const char* name, const char* desc) 548 : TestCase (context, name, desc) 549 , m_verifier (verifier) 550 { 551 } 552 553 ActiveAtomicCounterBuffersCase::IterateResult ActiveAtomicCounterBuffersCase::iterate (void) 554 { 555 static const char* const s_computeTemplate0 = "${GLSL_VERSION_DECL}\n" 556 "layout (local_size_x = 3) in;\n" 557 "layout(binding = 0) buffer Output\n" 558 "{\n" 559 " highp float val;\n" 560 "} sb_out;\n" 561 "\n" 562 "void main (void)\n" 563 "{\n" 564 " sb_out.val = 1.0;\n" 565 "}\n"; 566 static const char* const s_computeTemplate1 = "${GLSL_VERSION_DECL}\n" 567 "layout (local_size_x = 3) in;\n" 568 "layout(binding = 0) uniform highp atomic_uint u_counters[2];\n" 569 "layout(binding = 0) buffer Output\n" 570 "{\n" 571 " highp float val;\n" 572 "} sb_out;\n" 573 "\n" 574 "void main (void)\n" 575 "{\n" 576 " sb_out.val = float(atomicCounterIncrement(u_counters[0])) + float(atomicCounterIncrement(u_counters[1]));\n" 577 "}\n"; 578 579 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 580 tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: "); 581 582 gl.enableLogging(true); 583 584 { 585 const tcu::ScopedLogSection section (m_testCtx.getLog(), "Initial", "Initial"); 586 glu::Program program (m_context.getRenderContext()); 587 588 verifyStateProgramInteger(result, gl, program.getProgram(), GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, 0, m_verifier); 589 } 590 591 { 592 const tcu::ScopedLogSection section (m_testCtx.getLog(), "NoBuffers", "No buffers"); 593 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate0))); 594 595 m_testCtx.getLog() << program; 596 597 TCU_CHECK_MSG(program.isOk(), "failed to build program"); 598 599 verifyStateProgramInteger(result, gl, program.getProgram(), GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, 0, m_verifier); 600 } 601 602 { 603 const tcu::ScopedLogSection section (m_testCtx.getLog(), "OneBuffer", "One buffer"); 604 glu::ShaderProgram program (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, s_computeTemplate1))); 605 606 m_testCtx.getLog() << program; 607 608 TCU_CHECK_MSG(program.isOk(), "failed to build program"); 609 610 verifyStateProgramInteger(result, gl, program.getProgram(), GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, 1, m_verifier); 611 } 612 613 result.setTestContextResult(m_testCtx); 614 return STOP; 615 } 616 617 class ProgramLogCase : public TestCase 618 { 619 public: 620 enum BuildErrorType 621 { 622 BUILDERROR_VERTEX_FRAGMENT = 0, 623 BUILDERROR_COMPUTE, 624 BUILDERROR_GEOMETRY, 625 BUILDERROR_TESSELLATION, 626 }; 627 628 ProgramLogCase (Context& ctx, const char* name, const char* desc, BuildErrorType errorType); 629 630 private: 631 void init (void); 632 IterateResult iterate (void); 633 glu::ProgramSources getProgramSources (void) const; 634 635 const BuildErrorType m_buildErrorType; 636 }; 637 638 ProgramLogCase::ProgramLogCase (Context& ctx, const char* name, const char* desc, BuildErrorType errorType) 639 : TestCase (ctx, name, desc) 640 , m_buildErrorType (errorType) 641 { 642 } 643 644 void ProgramLogCase::init (void) 645 { 646 const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)); 647 648 switch (m_buildErrorType) 649 { 650 case BUILDERROR_VERTEX_FRAGMENT: 651 case BUILDERROR_COMPUTE: 652 break; 653 654 case BUILDERROR_GEOMETRY: 655 if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) 656 TCU_THROW(NotSupportedError, "Test requires GL_EXT_geometry_shader extension"); 657 break; 658 659 case BUILDERROR_TESSELLATION: 660 if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader")) 661 TCU_THROW(NotSupportedError, "Test requires GL_EXT_tessellation_shader extension"); 662 break; 663 664 default: 665 DE_ASSERT(false); 666 break; 667 } 668 } 669 670 ProgramLogCase::IterateResult ProgramLogCase::iterate (void) 671 { 672 using gls::StateQueryUtil::StateQueryMemoryWriteGuard; 673 674 tcu::ResultCollector result (m_testCtx.getLog()); 675 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 676 glu::ShaderProgram program (m_context.getRenderContext(), getProgramSources()); 677 StateQueryMemoryWriteGuard<glw::GLint> logLen; 678 679 gl.enableLogging(true); 680 681 m_testCtx.getLog() << tcu::TestLog::Message << "Trying to link a broken program." << tcu::TestLog::EndMessage; 682 683 gl.glGetProgramiv(program.getProgram(), GL_INFO_LOG_LENGTH, &logLen); 684 logLen.verifyValidity(result); 685 686 if (logLen.verifyValidity(result)) 687 verifyInfoLogQuery(result, gl, logLen, program.getProgram(), &glu::CallLogWrapper::glGetProgramInfoLog, "glGetProgramInfoLog"); 688 689 result.setTestContextResult(m_testCtx); 690 return STOP; 691 } 692 693 glu::ProgramSources ProgramLogCase::getProgramSources (void) const 694 { 695 const char* const vertexTemplate1 = "${GLSL_VERSION_DECL}\n" 696 "in highp vec4 a_pos;\n" 697 "uniform highp vec4 u_uniform;\n" 698 "void main()\n" 699 "{\n" 700 " gl_Position = a_pos + u_uniform;\n" 701 "}\n"; 702 const char* const vertexTemplate2 = "${GLSL_VERSION_DECL}\n" 703 "in highp vec4 a_pos;\n" 704 "void main()\n" 705 "{\n" 706 " gl_Position = a_pos;\n" 707 "}\n"; 708 const char* const fragmentTemplate1 = "${GLSL_VERSION_DECL}\n" 709 "in highp vec4 v_missingVar;\n" 710 "uniform highp int u_uniform;\n" 711 "layout(location = 0) out mediump vec4 fragColor;\n" 712 "void main()\n" 713 "{\n" 714 " fragColor = v_missingVar + vec4(float(u_uniform));\n" 715 "}\n"; 716 717 const char* const fragmentTemplate2 = "${GLSL_VERSION_DECL}\n" 718 "layout(location = 0) out mediump vec4 fragColor;\n" 719 "void main()\n" 720 "{\n" 721 " fragColor = vec4(1.0);\n" 722 "}\n"; 723 const char* const computeTemplate1 = "${GLSL_VERSION_DECL}\n" 724 "layout (binding = 0) buffer IOBuffer { highp float buf_var; };\n" 725 "uniform highp vec4 u_uniform;\n" 726 "void main()\n" 727 "{\n" 728 " buf_var = u_uniform.x;\n" 729 "}\n"; 730 const char* const geometryTemplate1 = "${GLSL_VERSION_DECL}\n" 731 "${GEOMETRY_SHADER_REQUIRE}\n" 732 "layout(triangles) in;\n" 733 "layout(max_vertices=1, points) out;\n" 734 "in highp vec4 v_missingVar[];\n" 735 "uniform highp int u_uniform;\n" 736 "void main()\n" 737 "{\n" 738 " gl_Position = gl_in[0].gl_Position + v_missingVar[2] + vec4(float(u_uniform));\n" 739 " EmitVertex();\n" 740 "}\n"; 741 const char* const tessCtrlTemplate1 = "${GLSL_VERSION_DECL}\n" 742 "${TESSELLATION_SHADER_REQUIRE}\n" 743 "layout(vertices=2) out;" 744 "patch out highp vec2 vp_var;\n" 745 "void main()\n" 746 "{\n" 747 " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position\n" 748 " gl_TessLevelOuter[0] = 0.8;\n" 749 " gl_TessLevelOuter[1] = 0.8;\n" 750 " if (gl_InvocationID == 0)\n" 751 " vp_var = gl_in[gl_InvocationID].gl_Position.xy;\n" 752 "}\n"; 753 const char* const tessEvalTemplate1 = "${GLSL_VERSION_DECL}\n" 754 "${TESSELLATION_SHADER_REQUIRE}\n" 755 "layout(isolines) in;" 756 "in highp float vp_var[];\n" 757 "void main()\n" 758 "{\n" 759 " gl_Position = gl_in[gl_InvocationID].gl_Position + vec4(vp_var[1]);\n" 760 "}\n"; 761 762 switch (m_buildErrorType) 763 { 764 case BUILDERROR_VERTEX_FRAGMENT: 765 return glu::ProgramSources() 766 << glu::VertexSource(specializeShader(m_context, vertexTemplate1)) 767 << glu::FragmentSource(specializeShader(m_context, fragmentTemplate1)); 768 769 case BUILDERROR_COMPUTE: 770 return glu::ProgramSources() 771 << glu::ComputeSource(specializeShader(m_context, computeTemplate1)); 772 773 case BUILDERROR_GEOMETRY: 774 return glu::ProgramSources() 775 << glu::VertexSource(specializeShader(m_context, vertexTemplate1)) 776 << glu::GeometrySource(specializeShader(m_context, geometryTemplate1)) 777 << glu::FragmentSource(specializeShader(m_context, fragmentTemplate2)); 778 779 case BUILDERROR_TESSELLATION: 780 return glu::ProgramSources() 781 << glu::VertexSource(specializeShader(m_context, vertexTemplate2)) 782 << glu::TessellationControlSource(specializeShader(m_context, tessCtrlTemplate1)) 783 << glu::TessellationEvaluationSource(specializeShader(m_context, tessEvalTemplate1)) 784 << glu::FragmentSource(specializeShader(m_context, fragmentTemplate2)); 785 786 default: 787 DE_ASSERT(false); 788 return glu::ProgramSources(); 789 } 790 } 791 792 } // anonymous 793 794 ProgramStateQueryTests::ProgramStateQueryTests (Context& context) 795 : TestCaseGroup(context, "program", "Program State Query tests") 796 { 797 } 798 799 ProgramStateQueryTests::~ProgramStateQueryTests (void) 800 { 801 } 802 803 void ProgramStateQueryTests::init (void) 804 { 805 static const QueryType intVerifiers[] = 806 { 807 QUERY_PROGRAM_INTEGER, 808 }; 809 static const QueryType intVec3Verifiers[] = 810 { 811 QUERY_PROGRAM_INTEGER_VEC3, 812 }; 813 814 #define FOR_EACH_INT_VERIFIER(X) \ 815 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVerifiers); ++verifierNdx) \ 816 { \ 817 const char* verifierSuffix = getVerifierSuffix(intVerifiers[verifierNdx]); \ 818 const QueryType verifier = intVerifiers[verifierNdx]; \ 819 this->addChild(X); \ 820 } 821 822 #define FOR_EACH_VEC_VERIFIER(X) \ 823 for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(intVec3Verifiers); ++verifierNdx) \ 824 { \ 825 const char* verifierSuffix = getVerifierSuffix(intVec3Verifiers[verifierNdx]); \ 826 const QueryType verifier = intVec3Verifiers[verifierNdx]; \ 827 this->addChild(X); \ 828 } 829 830 FOR_EACH_INT_VERIFIER(new ProgramSeparableCase (m_context, verifier, (std::string("program_separable_") + verifierSuffix).c_str(), "Test PROGRAM_SEPARABLE")); 831 FOR_EACH_VEC_VERIFIER(new ComputeWorkGroupSizeCase (m_context, verifier, (std::string("compute_work_group_size_") + verifierSuffix).c_str(), "Test COMPUTE_WORK_GROUP_SIZE")); 832 FOR_EACH_INT_VERIFIER(new ActiveAtomicCounterBuffersCase (m_context, verifier, (std::string("active_atomic_counter_buffers_") + verifierSuffix).c_str(), "Test ACTIVE_ATOMIC_COUNTER_BUFFERS")); 833 FOR_EACH_INT_VERIFIER(new GeometryShaderCase (m_context, verifier, (std::string("geometry_shader_state_") + verifierSuffix).c_str(), "Test Geometry Shader State")); 834 FOR_EACH_INT_VERIFIER(new TessellationShaderCase (m_context, verifier, (std::string("tesselation_shader_state_") + verifierSuffix).c_str(), "Test Tesselation Shader State")); 835 836 #undef FOR_EACH_INT_VERIFIER 837 #undef FOR_EACH_VEC_VERIFIER 838 839 // program info log tests 840 // \note, there exists similar tests in gles3 module. However, the gles31 could use a different 841 // shader compiler with different INFO_LOG bugs. 842 { 843 static const struct 844 { 845 const char* caseName; 846 ProgramLogCase::BuildErrorType caseType; 847 } shaderTypes[] = 848 { 849 { "info_log_vertex_fragment_link_fail", ProgramLogCase::BUILDERROR_VERTEX_FRAGMENT }, 850 { "info_log_compute_link_fail", ProgramLogCase::BUILDERROR_COMPUTE }, 851 { "info_log_geometry_link_fail", ProgramLogCase::BUILDERROR_GEOMETRY }, 852 { "info_log_tessellation_link_fail", ProgramLogCase::BUILDERROR_TESSELLATION }, 853 }; 854 855 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ++ndx) 856 addChild(new ProgramLogCase(m_context, shaderTypes[ndx].caseName, "", shaderTypes[ndx].caseType)); 857 } 858 } 859 860 } // Functional 861 } // gles31 862 } // deqp 863
