1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2015-2016 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 21 * \brief 22 */ /*-------------------------------------------------------------------*/ 23 #include "esextcGeometryShaderAPI.hpp" 24 25 #include "gluDefs.hpp" 26 #include "glwEnums.hpp" 27 #include "glwFunctions.hpp" 28 #include "tcuTestLog.hpp" 29 #include <cstring> 30 31 namespace glcts 32 { 33 34 static const char* dummy_fs_code = "${VERSION}\n" 35 "\n" 36 "precision highp float;\n" 37 "\n" 38 "out vec4 result;\n" 39 "\n" 40 "void main()\n" 41 "{\n" 42 " result = vec4(1.0);\n" 43 "}\n"; 44 45 static const char* dummy_gs_code = "${VERSION}\n" 46 "${GEOMETRY_SHADER_REQUIRE}\n" 47 "\n" 48 "layout (points) in;\n" 49 "layout (points, max_vertices = 1) out;\n" 50 "\n" 51 "${OUT_PER_VERTEX_DECL}" 52 "${IN_DATA_DECL}" 53 "void main()\n" 54 "{\n" 55 "${POSITION_WITH_IN_DATA}" 56 " EmitVertex();\n" 57 "}\n"; 58 59 static const char* dummy_vs_code = "${VERSION}\n" 60 "\n" 61 "${OUT_PER_VERTEX_DECL}" 62 "\n" 63 "void main()\n" 64 "{\n" 65 " gl_Position = vec4(1.0, 0.0, 0.0, 1.0);\n" 66 "}\n"; 67 68 /* createShaderProgramv conformance test shaders */ 69 const char* GeometryShaderCreateShaderProgramvTest::fs_code = "${VERSION}\n" 70 "\n" 71 "precision highp float;\n" 72 "\n" 73 "out vec4 result;\n" 74 "\n" 75 "void main()\n" 76 "{\n" 77 " result = vec4(0.0, 1.0, 0.0, 0.0);\n" 78 "}\n"; 79 80 const char* GeometryShaderCreateShaderProgramvTest::gs_code = "${VERSION}\n" 81 "${GEOMETRY_SHADER_REQUIRE}\n" 82 "\n" 83 "layout (points) in;\n" 84 "layout (triangle_strip, max_vertices = 4) out;\n" 85 "\n" 86 "${OUT_PER_VERTEX_DECL}" 87 "\n" 88 "void main()\n" 89 "{\n" 90 " gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n" 91 " EmitVertex();\n" 92 "\n" 93 " gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n" 94 " EmitVertex();\n" 95 "\n" 96 " gl_Position = vec4(1.0, -1.0, 0.0, 1.0);\n" 97 " EmitVertex();\n" 98 "\n" 99 " gl_Position = vec4(1.0, 1.0, 0.0, 1.0);\n" 100 " EmitVertex();\n" 101 " EndPrimitive();\n" 102 "}\n"; 103 104 const char* GeometryShaderCreateShaderProgramvTest::vs_code = "${VERSION}\n" 105 "\n" 106 "${OUT_PER_VERTEX_DECL}" 107 "\n" 108 "void main()\n" 109 "{\n" 110 " gl_Position = vec4(-10.0, -10.0, -10.0, 0.0);\n" 111 "}\n"; 112 113 const unsigned int GeometryShaderCreateShaderProgramvTest::m_to_height = 4; 114 const unsigned int GeometryShaderCreateShaderProgramvTest::m_to_width = 4; 115 116 /** Constructor 117 * 118 * @param context Test context 119 * @param extParams Not used. 120 * @param name Test case's name 121 * @param description Test case's description 122 **/ 123 GeometryShaderCreateShaderProgramvTest::GeometryShaderCreateShaderProgramvTest(Context& context, 124 const ExtParameters& extParams, 125 const char* name, 126 const char* description) 127 : TestCaseBase(context, extParams, name, description) 128 , m_fbo_id(0) 129 , m_fs_po_id(0) 130 , m_gs_po_id(0) 131 , m_pipeline_object_id(0) 132 , m_to_id(0) 133 , m_vao_id(0) 134 , m_vs_po_id(0) 135 { 136 } 137 138 /** Deinitializes GLES objects created during the test. */ 139 void GeometryShaderCreateShaderProgramvTest::deinit() 140 { 141 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 142 143 if (m_fbo_id != 0) 144 { 145 gl.deleteFramebuffers(1, &m_fbo_id); 146 147 m_fbo_id = 0; 148 } 149 150 if (m_fs_po_id != 0) 151 { 152 gl.deleteProgram(m_fs_po_id); 153 154 m_fs_po_id = 0; 155 } 156 157 if (m_gs_po_id != 0) 158 { 159 gl.deleteProgram(m_gs_po_id); 160 161 m_gs_po_id = 0; 162 } 163 164 if (m_pipeline_object_id != 0) 165 { 166 gl.deleteProgramPipelines(1, &m_pipeline_object_id); 167 168 m_pipeline_object_id = 0; 169 } 170 171 if (m_to_id != 0) 172 { 173 gl.deleteTextures(1, &m_to_id); 174 175 m_to_id = 0; 176 } 177 178 if (m_vao_id != 0) 179 { 180 gl.deleteVertexArrays(1, &m_vao_id); 181 182 m_vao_id = 0; 183 } 184 185 if (m_vs_po_id != 0) 186 { 187 gl.deleteProgram(m_vs_po_id); 188 189 m_vs_po_id = 0; 190 } 191 192 /* Release base class */ 193 TestCaseBase::deinit(); 194 } 195 196 /** Initializes a framebuffer object used by the conformance test. */ 197 void GeometryShaderCreateShaderProgramvTest::initFBO() 198 { 199 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 200 201 /* Generate a FBO */ 202 gl.genFramebuffers(1, &m_fbo_id); 203 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed."); 204 205 /* Generate a TO */ 206 gl.genTextures(1, &m_to_id); 207 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); 208 209 /* Set the TO up */ 210 gl.bindTexture(GL_TEXTURE_2D, m_to_id); 211 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); 212 213 gl.texStorage2D(GL_TEXTURE_2D, 1, /* levels */ 214 GL_RGBA8, m_to_width, m_to_height); 215 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed."); 216 217 /* Set up the FBO */ 218 gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); 219 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed."); 220 221 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0); /* level */ 222 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed."); 223 224 /* Set up the viewport */ 225 gl.viewport(0, /* x */ 226 0, /* y */ 227 m_to_width, m_to_height); 228 229 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed."); 230 } 231 232 /* Initializes a pipeline object used by the conformance test */ 233 void GeometryShaderCreateShaderProgramvTest::initPipelineObject() 234 { 235 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 236 237 DE_ASSERT(m_fs_po_id != 0 && m_gs_po_id != 0 && m_vs_po_id != 0); 238 239 gl.genProgramPipelines(1, &m_pipeline_object_id); 240 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); 241 242 gl.useProgramStages(m_pipeline_object_id, GL_FRAGMENT_SHADER_BIT, m_fs_po_id); 243 gl.useProgramStages(m_pipeline_object_id, GL_GEOMETRY_SHADER_BIT, m_gs_po_id); 244 gl.useProgramStages(m_pipeline_object_id, GL_VERTEX_SHADER_BIT, m_vs_po_id); 245 246 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call(s) failed."); 247 } 248 249 /** Executes the test. 250 * 251 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 252 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 253 * Note the function throws exception should an error occur! 254 **/ 255 tcu::TestNode::IterateResult GeometryShaderCreateShaderProgramvTest::iterate() 256 { 257 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 258 const unsigned int n_so_po_ids = 3; 259 bool result = true; 260 glw::GLuint so_po_ids[n_so_po_ids]; 261 262 /* This test should only run if EXT_geometry_shader is supported. */ 263 if (!m_is_geometry_shader_extension_supported) 264 { 265 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 266 } 267 268 /* Initialize off-screen rendering */ 269 initFBO(); 270 271 /* Form shader sources */ 272 std::string fs_specialized_code = specializeShader(1, 273 /* parts */ &fs_code); 274 const char* fs_specialized_code_raw = fs_specialized_code.c_str(); 275 std::string gs_specialized_code = specializeShader(1, 276 /* parts */ &gs_code); 277 const char* gs_specialized_code_raw = gs_specialized_code.c_str(); 278 std::string vs_specialized_code = specializeShader(1, 279 /* parts */ &vs_code); 280 const char* vs_specialized_code_raw = vs_specialized_code.c_str(); 281 282 /* Try to create an invalid geometry shader program first */ 283 glw::GLint link_status = GL_TRUE; 284 285 m_gs_po_id = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1, /* count */ 286 &gs_code); 287 288 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 289 290 if (m_gs_po_id == 0) 291 { 292 m_testCtx.getLog() << tcu::TestLog::Message << "glCreateShaderProgramv() call returned 0." 293 << tcu::TestLog::EndMessage; 294 295 result = false; 296 goto end; 297 } 298 299 gl.getProgramiv(m_gs_po_id, GL_LINK_STATUS, &link_status); 300 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 301 302 if (link_status != GL_FALSE) 303 { 304 m_testCtx.getLog() << tcu::TestLog::Message << "An invalid shader program was linked successfully." 305 << tcu::TestLog::EndMessage; 306 307 result = false; 308 goto end; 309 } 310 311 gl.deleteProgram(m_gs_po_id); 312 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteProgram() call failed."); 313 314 /* Create shader programs */ 315 m_fs_po_id = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1, /* count */ 316 &fs_specialized_code_raw); 317 m_gs_po_id = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1, /* count */ 318 &gs_specialized_code_raw); 319 m_vs_po_id = gl.createShaderProgramv(GL_VERTEX_SHADER, 1, /* count */ 320 &vs_specialized_code_raw); 321 322 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call(s) failed."); 323 324 if (m_fs_po_id == 0 || m_gs_po_id == 0 || m_vs_po_id == 0) 325 { 326 m_testCtx.getLog() << tcu::TestLog::Message << "At least one glCreateShaderProgramv() call returned 0." 327 << tcu::TestLog::EndMessage; 328 329 result = false; 330 goto end; 331 } 332 333 /* Make sure all shader programs were linked successfully */ 334 so_po_ids[0] = m_fs_po_id; 335 so_po_ids[1] = m_gs_po_id; 336 so_po_ids[2] = m_vs_po_id; 337 338 for (unsigned int n_po_id = 0; n_po_id != n_so_po_ids; ++n_po_id) 339 { 340 gl.getProgramiv(so_po_ids[n_po_id], GL_LINK_STATUS, &link_status); 341 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 342 343 if (link_status != GL_TRUE) 344 { 345 m_testCtx.getLog() << tcu::TestLog::Message << "A valid shader program with id [" << so_po_ids[n_po_id] 346 << "] was not linked successfully." << tcu::TestLog::EndMessage; 347 348 result = false; 349 goto end; 350 } 351 } 352 353 /* Set up the vertex array object */ 354 gl.genVertexArrays(1, &m_vao_id); 355 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 356 357 gl.bindVertexArray(m_vao_id); 358 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 359 360 /* Set up the pipeline object */ 361 initPipelineObject(); 362 363 /* Render a full-screen quad */ 364 gl.bindProgramPipeline(m_pipeline_object_id); 365 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 366 367 gl.drawArrays(GL_POINTS, 0, /* first */ 368 1); /* count */ 369 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 370 371 /* Verify the rendering result */ 372 unsigned char result_data[m_to_width * m_to_height * 4 /* rgba */]; 373 374 gl.readPixels(0, /* x */ 375 0, /* y */ 376 m_to_width, m_to_height, GL_RGBA, GL_UNSIGNED_BYTE, result_data); 377 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed."); 378 379 for (unsigned int y = 0; y < m_to_height; ++y) 380 { 381 unsigned char* traveller_ptr = result_data + 4 * y; 382 383 for (unsigned int x = 0; x < m_to_width; ++x) 384 { 385 if (traveller_ptr[0] != 0 || traveller_ptr[1] != 255 || traveller_ptr[2] != 0 || traveller_ptr[3] != 0) 386 { 387 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid result texel found at (" << x << ", " << y 388 << ")." << tcu::TestLog::EndMessage; 389 390 result = false; 391 } 392 393 traveller_ptr += 4; /* rgba */ 394 } 395 } 396 397 end: 398 if (result) 399 { 400 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 401 } 402 else 403 { 404 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 405 } 406 407 return STOP; 408 } 409 410 /** Constructor 411 * 412 * @param context Test context 413 * @param extParams Not used. 414 * @param name Test case's name 415 * @param description Test case's description 416 **/ 417 GeometryShaderGetShaderivTest::GeometryShaderGetShaderivTest(Context& context, const ExtParameters& extParams, 418 const char* name, const char* description) 419 : TestCaseBase(context, extParams, name, description), m_gs_id(0) 420 { 421 } 422 423 /** Deinitializes GLES objects created during the test. */ 424 void GeometryShaderGetShaderivTest::deinit() 425 { 426 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 427 428 if (m_gs_id != 0) 429 { 430 gl.deleteShader(m_gs_id); 431 432 m_gs_id = 0; 433 } 434 435 /* Release base class */ 436 TestCaseBase::deinit(); 437 } 438 439 /** Executes the test. 440 * 441 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 442 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 443 * Note the function throws exception should an error occur! 444 **/ 445 tcu::TestNode::IterateResult GeometryShaderGetShaderivTest::iterate() 446 { 447 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 448 bool result = true; 449 450 /* This test should only run if EXT_geometry_shader is supported. */ 451 if (!m_is_geometry_shader_extension_supported) 452 { 453 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 454 } 455 456 /* Create a GS */ 457 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 458 459 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 460 461 /* Check the type reported for the SO */ 462 glw::GLint shader_type = GL_NONE; 463 464 gl.getShaderiv(m_gs_id, GL_SHADER_TYPE, &shader_type); 465 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 466 467 if ((glw::GLenum)shader_type != m_glExtTokens.GEOMETRY_SHADER) 468 { 469 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid shader type [" << shader_type 470 << "] reported for a Geometry Shader" << tcu::TestLog::EndMessage; 471 472 result = false; 473 } 474 475 if (result) 476 { 477 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 478 } 479 else 480 { 481 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 482 } 483 484 return STOP; 485 } 486 487 /** Constructor 488 * 489 * @param context Test context 490 * @param extParams Not used. 491 * @param name Test case's name 492 * @param description Test case's description 493 **/ 494 GeometryShaderGetProgramivTest::GeometryShaderGetProgramivTest(Context& context, const ExtParameters& extParams, 495 const char* name, const char* description) 496 : TestCaseBase(context, extParams, name, description), m_po_id(0) 497 { 498 } 499 500 /** Deinitializes GLES objects created during the test. */ 501 void GeometryShaderGetProgramivTest::deinit() 502 { 503 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 504 505 if (m_po_id != 0) 506 { 507 gl.deleteProgram(m_po_id); 508 509 m_po_id = 0; 510 } 511 512 /* Release base class */ 513 TestCaseBase::deinit(); 514 } 515 516 /** Executes the test. 517 * 518 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 519 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 520 * Note the function throws exception should an error occur! 521 **/ 522 tcu::TestNode::IterateResult GeometryShaderGetProgramivTest::iterate() 523 { 524 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 525 bool result = true; 526 527 /* This test should only run if EXT_geometry_shader is supported. */ 528 if (!m_is_geometry_shader_extension_supported) 529 { 530 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 531 } 532 533 /* Create a program object */ 534 m_po_id = gl.createProgram(); 535 536 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 537 538 /* Verify that GS-specific queries cause a GL_INVALID_OPERATION error */ 539 const glw::GLenum pnames[] = { m_glExtTokens.GEOMETRY_LINKED_VERTICES_OUT, m_glExtTokens.GEOMETRY_LINKED_INPUT_TYPE, 540 m_glExtTokens.GEOMETRY_LINKED_OUTPUT_TYPE, 541 m_glExtTokens.GEOMETRY_SHADER_INVOCATIONS }; 542 const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]); 543 544 for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname) 545 { 546 glw::GLenum error_code = GL_NO_ERROR; 547 glw::GLenum pname = pnames[n_pname]; 548 glw::GLint rv = -1; 549 550 gl.getProgramiv(m_po_id, pname, &rv); 551 552 error_code = gl.getError(); 553 554 if (error_code != GL_INVALID_OPERATION) 555 { 556 m_testCtx.getLog() << tcu::TestLog::Message << "No error generated by glGetProgramiv() for pname [" << pname 557 << "]" << tcu::TestLog::EndMessage; 558 559 result = false; 560 } 561 } /* for (all pnames) */ 562 563 if (result) 564 { 565 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 566 } 567 else 568 { 569 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 570 } 571 572 return STOP; 573 } 574 575 /** Constructor 576 * 577 * @param context Test context 578 * @param extParams Not used. 579 * @param name Test case's name 580 * @param description Test case's description 581 **/ 582 GeometryShaderGetProgramiv2Test::GeometryShaderGetProgramiv2Test(Context& context, const ExtParameters& extParams, 583 const char* name, const char* description) 584 : TestCaseBase(context, extParams, name, description), m_fs_id(0), m_po_id(0), m_vs_id(0) 585 { 586 } 587 588 /** Deinitializes GLES objects created during the test. */ 589 void GeometryShaderGetProgramiv2Test::deinit() 590 { 591 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 592 593 if (m_fs_id != 0) 594 { 595 gl.deleteShader(m_fs_id); 596 597 m_fs_id = 0; 598 } 599 600 if (m_po_id != 0) 601 { 602 gl.deleteProgram(m_po_id); 603 604 m_po_id = 0; 605 } 606 607 if (m_vs_id != 0) 608 { 609 gl.deleteShader(m_vs_id); 610 611 m_vs_id = 0; 612 } 613 614 /* Release base class */ 615 TestCaseBase::deinit(); 616 } 617 618 /** Executes the test. 619 * 620 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 621 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 622 * Note the function throws exception should an error occur! 623 **/ 624 tcu::TestNode::IterateResult GeometryShaderGetProgramiv2Test::iterate() 625 { 626 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 627 const glw::GLenum pnames[] = { m_glExtTokens.GEOMETRY_LINKED_VERTICES_OUT, m_glExtTokens.GEOMETRY_LINKED_INPUT_TYPE, 628 m_glExtTokens.GEOMETRY_LINKED_OUTPUT_TYPE, 629 m_glExtTokens.GEOMETRY_SHADER_INVOCATIONS }; 630 const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]); 631 bool result = true; 632 633 /* This test should only run if EXT_geometry_shader is supported. */ 634 if (!m_is_geometry_shader_extension_supported) 635 { 636 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 637 } 638 639 /* Initialize the program object */ 640 std::string specialized_dummy_fs = specializeShader(1, 641 /* parts */ &dummy_fs_code); 642 const char* specialized_dummy_fs_raw = specialized_dummy_fs.c_str(); 643 std::string specialized_dummy_vs = specializeShader(1, 644 /* parts */ &dummy_vs_code); 645 const char* specialized_dummy_vs_raw = specialized_dummy_vs.c_str(); 646 647 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 648 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 649 650 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 651 652 m_po_id = gl.createProgram(); 653 654 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 655 656 if (!TestCaseBase::buildProgram(m_po_id, m_fs_id, 1, &specialized_dummy_fs_raw, m_vs_id, 1, 657 &specialized_dummy_vs_raw)) 658 { 659 m_testCtx.getLog() << tcu::TestLog::Message << "Failed to build a dummy test program object" 660 << tcu::TestLog::EndMessage; 661 662 result = false; 663 goto end; 664 } 665 666 /* Verify that GS-specific queries cause a GL_INVALID_OPERATION error 667 * for a linked PO lacking the GS stage. 668 */ 669 for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname) 670 { 671 glw::GLenum error_code = GL_NO_ERROR; 672 glw::GLenum pname = pnames[n_pname]; 673 glw::GLint rv = -1; 674 675 gl.getProgramiv(m_po_id, pname, &rv); 676 677 error_code = gl.getError(); 678 679 if (error_code != GL_INVALID_OPERATION) 680 { 681 m_testCtx.getLog() << tcu::TestLog::Message << "No error generated by glGetProgramiv() for pname [" << pname 682 << "]" << tcu::TestLog::EndMessage; 683 684 result = false; 685 } 686 } /* for (all pnames) */ 687 688 end: 689 if (result) 690 { 691 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 692 } 693 else 694 { 695 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 696 } 697 698 return STOP; 699 } 700 701 /** Constructor 702 * 703 * @param context Test context 704 * @param extParams Not used. 705 * @param name Test case's name 706 * @param description Test case's description 707 **/ 708 GeometryShaderGetProgramiv3Test::GeometryShaderGetProgramiv3Test(Context& context, const ExtParameters& extParams, 709 const char* name, const char* description) 710 : TestCaseBase(context, extParams, name, description) 711 , m_fs_id(0) 712 , m_fs_po_id(0) 713 , m_gs_id(0) 714 , m_gs_po_id(0) 715 , m_pipeline_object_id(0) 716 , m_po_id(0) 717 , m_vs_id(0) 718 , m_vs_po_id(0) 719 { 720 } 721 722 /* Compiles a shader object using caller-specified data. 723 * 724 * @param so_id ID of a Shader Object to compile. 725 * @param so_body Body to use for the compilation process. 726 * 727 * @return true if the compilation succeeded, false otherwise */ 728 bool GeometryShaderGetProgramiv3Test::buildShader(glw::GLuint so_id, const char* so_body) 729 { 730 glw::GLint compile_status = GL_FALSE; 731 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 732 bool result = false; 733 734 gl.shaderSource(so_id, 1, /* count */ 735 &so_body, DE_NULL); /* length */ 736 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 737 738 gl.compileShader(so_id); 739 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); 740 741 gl.getShaderiv(so_id, GL_COMPILE_STATUS, &compile_status); 742 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 743 744 result = (compile_status == GL_TRUE); 745 746 return result; 747 } 748 749 /** Builds a single shader program object using caller-specified data. 750 * 751 * @param out_spo_id Deref will be set to the ID of the created shader program object. 752 * Must not be NULL. 753 * @param spo_bits Bits to be passed to the glCreateShaderProgramv() call. 754 * @param spo_body Body to use for the glCreateShaderProgramv() call. 755 * 756 * @return true if the shader program object was linked successfully, false otherwise. 757 */ 758 bool GeometryShaderGetProgramiv3Test::buildShaderProgram(glw::GLuint* out_spo_id, glw::GLenum spo_bits, 759 const char* spo_body) 760 { 761 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 762 glw::GLint link_status = GL_FALSE; 763 bool result = true; 764 765 *out_spo_id = gl.createShaderProgramv(spo_bits, 1, /* count */ 766 &spo_body); 767 768 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 769 770 gl.getProgramiv(*out_spo_id, GL_LINK_STATUS, &link_status); 771 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 772 773 result = (link_status == GL_TRUE); 774 775 return result; 776 } 777 778 /** Deinitializes GLES objects created during the test. */ 779 void GeometryShaderGetProgramiv3Test::deinit() 780 { 781 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 782 783 deinitPO(); 784 deinitSOs(true); 785 deinitSPOs(true); 786 787 if (m_pipeline_object_id != 0) 788 { 789 gl.deleteProgramPipelines(1, &m_pipeline_object_id); 790 791 m_pipeline_object_id = 0; 792 } 793 794 /* Release base class */ 795 TestCaseBase::deinit(); 796 } 797 798 /** Deinitializes a program object created for the conformance test. */ 799 void GeometryShaderGetProgramiv3Test::deinitPO() 800 { 801 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 802 803 if (m_po_id != 0) 804 { 805 gl.deleteProgram(m_po_id); 806 807 m_po_id = 0; 808 } 809 } 810 811 /** Deinitializes shader objects created for the conformance test. */ 812 void GeometryShaderGetProgramiv3Test::deinitSOs(bool release_all_SOs) 813 { 814 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 815 816 if (m_fs_id != 0 && release_all_SOs) 817 { 818 gl.deleteShader(m_fs_id); 819 820 m_fs_id = 0; 821 } 822 823 if (m_gs_id != 0) 824 { 825 gl.deleteShader(m_gs_id); 826 827 m_gs_id = 0; 828 } 829 830 if (m_vs_id != 0 && release_all_SOs) 831 { 832 gl.deleteShader(m_vs_id); 833 834 m_vs_id = 0; 835 } 836 } 837 838 /** Deinitializes shader program objects created for the conformance test. */ 839 void GeometryShaderGetProgramiv3Test::deinitSPOs(bool release_all_SPOs) 840 { 841 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 842 843 if (m_fs_po_id != 0 && release_all_SPOs) 844 { 845 gl.deleteProgram(m_fs_po_id); 846 847 m_fs_po_id = 0; 848 } 849 850 if (m_gs_po_id != 0) 851 { 852 gl.deleteProgram(m_gs_po_id); 853 854 m_gs_po_id = 0; 855 } 856 857 if (m_vs_po_id != 0 && release_all_SPOs) 858 { 859 gl.deleteProgram(m_vs_po_id); 860 861 m_vs_po_id = 0; 862 } 863 } 864 865 /** Retrieves ES SL layout qualifier, corresponding to user-specified 866 * primitive type. 867 * 868 * @param primitive_type Primitive type (described by a GLenum value) 869 * to use for the query. 870 * 871 * @return Requested layout qualifier. 872 */ 873 std::string GeometryShaderGetProgramiv3Test::getLayoutQualifierForPrimitiveType(glw::GLenum primitive_type) 874 { 875 std::string result; 876 877 switch (primitive_type) 878 { 879 case GL_LINE_STRIP: 880 result = "line_strip"; 881 break; 882 case GL_LINES_ADJACENCY: 883 result = "lines_adjacency"; 884 break; 885 case GL_POINTS: 886 result = "points"; 887 break; 888 case GL_TRIANGLES: 889 result = "triangles"; 890 break; 891 case GL_TRIANGLE_STRIP: 892 result = "triangle_strip"; 893 break; 894 895 default: 896 { 897 DE_ASSERT(0); 898 } 899 } /* switch (primitive_type) */ 900 901 return result; 902 } 903 904 /** Retrieves body of a geometry shadet to be used for the conformance test. 905 * The body is generated, according to the properties described by the 906 * run descriptor passed as an argument. 907 * 908 * @param run Test run descriptor. 909 * 910 * @return Requested string. 911 */ 912 std::string GeometryShaderGetProgramiv3Test::getGSCode(const _run& run) 913 { 914 std::stringstream code_sstream; 915 916 code_sstream << "${VERSION}\n" 917 "${GEOMETRY_SHADER_REQUIRE}\n" 918 "\n" 919 "layout(" 920 << getLayoutQualifierForPrimitiveType(run.input_primitive_type) << ", " 921 "invocations = " 922 << run.invocations << ") in;\n" 923 "layout(" 924 << getLayoutQualifierForPrimitiveType(run.output_primitive_type) << ", " 925 "max_vertices = " 926 << run.max_vertices << ") out;\n" 927 "\n" 928 "out gl_PerVertex {\n" 929 " vec4 gl_Position;\n" 930 "};\n" 931 "\n" 932 "void main()\n" 933 "{\n" 934 " for (int n = 0; n < " 935 << run.max_vertices << "; ++n)\n" 936 " {\n" 937 " gl_Position = vec4(n, 0.0, 0.0, 1.0);\n" 938 " EmitVertex();\n" 939 " }\n" 940 "\n" 941 " EndPrimitive();\n" 942 "}\n"; 943 944 return code_sstream.str(); 945 } 946 947 /** Initializes internal _runs member with test iteration settings for all test runs. */ 948 void GeometryShaderGetProgramiv3Test::initTestRuns() 949 { 950 /* input primitive type | invocations | max vertices | output primitive type * 951 *----------------------------------------+-------------+--------------+-----------------------*/ 952 _runs.push_back(_run(GL_LINES_ADJACENCY, 3, 16, GL_POINTS)); 953 _runs.push_back(_run(GL_TRIANGLES, 12, 37, GL_LINE_STRIP)); 954 _runs.push_back(_run(GL_POINTS, 31, 75, GL_TRIANGLE_STRIP)); 955 } 956 957 /** Executes the test. 958 * 959 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 960 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 961 * Note the function throws exception should an error occur! 962 **/ 963 tcu::TestNode::IterateResult GeometryShaderGetProgramiv3Test::iterate() 964 { 965 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 966 glw::GLint gs_spo_id = 0; 967 unsigned int n_run = 0; 968 unsigned int n_separable_object_case = 0; 969 bool result = true; 970 971 /* This test should only run if EXT_geometry_shader is supported. */ 972 if (!m_is_geometry_shader_extension_supported) 973 { 974 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 975 } 976 977 /* Prepare specialized versions of dummy fragment & vertex shaders */ 978 std::string dummy_fs_specialized = specializeShader(1, 979 /* parts */ &dummy_fs_code); 980 const char* dummy_fs_specialized_raw = dummy_fs_specialized.c_str(); 981 std::string dummy_vs_specialized = specializeShader(1, &dummy_vs_code); 982 const char* dummy_vs_specialized_raw = dummy_vs_specialized.c_str(); 983 984 /* Set up the fragment & the vertex shaders */ 985 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 986 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 987 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 988 989 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 990 991 if (!buildShader(m_fs_id, dummy_fs_specialized_raw) || !buildShader(m_vs_id, dummy_vs_specialized_raw)) 992 { 993 m_testCtx.getLog() << tcu::TestLog::Message << "Either FS or VS failed to build." << tcu::TestLog::EndMessage; 994 995 result = false; 996 goto end; 997 } 998 999 /* Set up the test program object */ 1000 m_po_id = gl.createProgram(); 1001 1002 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 1003 1004 gl.attachShader(m_po_id, m_fs_id); 1005 gl.attachShader(m_po_id, m_gs_id); 1006 gl.attachShader(m_po_id, m_vs_id); 1007 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call(s) failed."); 1008 1009 /* Set up the fragment & the vertex shader programs */ 1010 if (!buildShaderProgram(&m_fs_po_id, GL_FRAGMENT_SHADER, dummy_fs_specialized_raw) || 1011 !buildShaderProgram(&m_vs_po_id, GL_VERTEX_SHADER, dummy_vs_specialized_raw)) 1012 { 1013 m_testCtx.getLog() << tcu::TestLog::Message << "Either FS or VS SPOs failed to build." 1014 << tcu::TestLog::EndMessage; 1015 1016 result = false; 1017 goto end; 1018 } 1019 1020 /* Set up test runs */ 1021 initTestRuns(); 1022 1023 /* The test should check both a geometry shader program object and a full-blown PO 1024 * consisting of FS, GS and VS. */ 1025 for (n_separable_object_case = 0; n_separable_object_case < 2; /* PO, SPO cases */ 1026 ++n_separable_object_case) 1027 { 1028 bool should_use_separable_object = (n_separable_object_case != 0); 1029 1030 /* Iterate over all test runs */ 1031 for (n_run = 0; n_run < _runs.size(); ++n_run) 1032 { 1033 const _run& current_run = _runs[n_run]; 1034 std::string gs_code = getGSCode(current_run); 1035 const char* gs_code_raw = gs_code.c_str(); 1036 std::string gs_code_specialized = specializeShader(1, /* parts */ 1037 &gs_code_raw); 1038 const char* gs_code_specialized_raw = gs_code_specialized.c_str(); 1039 1040 if (should_use_separable_object) 1041 { 1042 /* Deinitialize any objects that may have been created in previous iterations */ 1043 deinitSPOs(false); 1044 1045 /* Set up the geometry shader program object */ 1046 if (!buildShaderProgram(&m_gs_po_id, GL_GEOMETRY_SHADER, gs_code_specialized_raw)) 1047 { 1048 m_testCtx.getLog() << tcu::TestLog::Message << "Failed to compile a geometry shader program object" 1049 << tcu::TestLog::EndMessage; 1050 1051 result = false; 1052 goto end; 1053 } 1054 } /* if (should_use_pipeline_object) */ 1055 else 1056 { 1057 gl.bindProgramPipeline(0); 1058 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 1059 1060 /* Set up the geometry shader object */ 1061 if (!buildShader(m_gs_id, gs_code_specialized_raw)) 1062 { 1063 m_testCtx.getLog() << tcu::TestLog::Message << "Failed to compile a geometry shader object." 1064 << tcu::TestLog::EndMessage; 1065 1066 result = false; 1067 goto end; 1068 } 1069 1070 /* Set up the program object */ 1071 glw::GLint link_status = GL_FALSE; 1072 1073 gl.linkProgram(m_po_id); 1074 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); 1075 1076 gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status); 1077 1078 if (link_status == GL_FALSE) 1079 { 1080 m_testCtx.getLog() << tcu::TestLog::Message << "Test program object failed to link" 1081 << tcu::TestLog::EndMessage; 1082 1083 result = false; 1084 goto end; 1085 } 1086 1087 /* Bind the PO to the rendering context */ 1088 gl.useProgram(m_po_id); 1089 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 1090 } 1091 1092 /* Execute the queries */ 1093 glw::GLuint po_id = (should_use_separable_object) ? m_gs_po_id : m_po_id; 1094 glw::GLint result_geometry_linked_vertices_out = 0; 1095 glw::GLint result_geometry_linked_input_type = 0; 1096 glw::GLint result_geometry_linked_output_type = 0; 1097 glw::GLint result_geometry_shader_invocations = 0; 1098 1099 gl.getProgramiv(po_id, m_glExtTokens.GEOMETRY_LINKED_VERTICES_OUT, &result_geometry_linked_vertices_out); 1100 GLU_EXPECT_NO_ERROR(gl.getError(), 1101 "glGetProgramiv() call failed for GL_GEOMETRY_LINKED_VERTICES_OUT_EXT query."); 1102 1103 gl.getProgramiv(po_id, m_glExtTokens.GEOMETRY_LINKED_INPUT_TYPE, &result_geometry_linked_input_type); 1104 GLU_EXPECT_NO_ERROR(gl.getError(), 1105 "glGetProgramiv() call failed for GL_GEOMETRY_LINKED_INPUT_TYPE_EXT query."); 1106 1107 gl.getProgramiv(po_id, m_glExtTokens.GEOMETRY_LINKED_OUTPUT_TYPE, &result_geometry_linked_output_type); 1108 GLU_EXPECT_NO_ERROR(gl.getError(), 1109 "glGetProgramiv() call failed for GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT query."); 1110 1111 gl.getProgramiv(po_id, m_glExtTokens.GEOMETRY_SHADER_INVOCATIONS, &result_geometry_shader_invocations); 1112 GLU_EXPECT_NO_ERROR(gl.getError(), 1113 "glGetProgramiv() call failed for GL_GEOMETRY_LINKED_INPUT_TYPE_EXT query."); 1114 1115 if (current_run.input_primitive_type != (glw::GLenum)result_geometry_linked_input_type) 1116 { 1117 m_testCtx.getLog() << tcu::TestLog::Message << "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT query value " 1118 << "[" << result_geometry_linked_input_type 1119 << "]" 1120 " does not match the test run setting " 1121 "[" 1122 << current_run.input_primitive_type << "]" << tcu::TestLog::EndMessage; 1123 1124 result = false; 1125 } 1126 1127 if (current_run.invocations != result_geometry_shader_invocations) 1128 { 1129 m_testCtx.getLog() << tcu::TestLog::Message << "GL_GEOMETRY_SHADER_INVOCATIONS_EXT query value " 1130 << "[" << result_geometry_shader_invocations 1131 << "]" 1132 " does not match the test run setting " 1133 "[" 1134 << current_run.input_primitive_type << "]" << tcu::TestLog::EndMessage; 1135 1136 result = false; 1137 } 1138 1139 if (current_run.max_vertices != result_geometry_linked_vertices_out) 1140 { 1141 m_testCtx.getLog() << tcu::TestLog::Message << "GL_GEOMETRY_LINKED_VERTICES_OUT query value " 1142 << "[" << result_geometry_linked_vertices_out 1143 << "]" 1144 " does not match the test run setting " 1145 "[" 1146 << current_run.max_vertices << "]" << tcu::TestLog::EndMessage; 1147 1148 result = false; 1149 } 1150 1151 if (current_run.output_primitive_type != (glw::GLenum)result_geometry_linked_output_type) 1152 { 1153 m_testCtx.getLog() << tcu::TestLog::Message << "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT query value " 1154 << "[" << result_geometry_linked_output_type 1155 << "]" 1156 " does not match the test run setting " 1157 "[" 1158 << current_run.output_primitive_type << "]" << tcu::TestLog::EndMessage; 1159 1160 result = false; 1161 } 1162 } /* for (all test runs) */ 1163 } /* for (PO & SPO cases) */ 1164 1165 /* One more check: build a pipeline object which only defines a FS & VS stages, 1166 * and check what GS SPO ID the object reports. */ 1167 gl.genProgramPipelines(1, &m_pipeline_object_id); 1168 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); 1169 1170 gl.useProgramStages(m_pipeline_object_id, GL_FRAGMENT_SHADER_BIT, m_fs_po_id); 1171 gl.useProgramStages(m_pipeline_object_id, GL_VERTEX_SHADER_BIT, m_vs_po_id); 1172 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 1173 1174 gl.getProgramPipelineiv(m_pipeline_object_id, m_glExtTokens.GEOMETRY_SHADER, &gs_spo_id); 1175 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramPipelineiv() call failed."); 1176 1177 if (gs_spo_id != 0) 1178 { 1179 m_testCtx.getLog() << tcu::TestLog::Message << "Pipeline object reported [" << gs_spo_id << "]" 1180 << " for GL_GEOMETRY_SHADER_EXT query, even though no GS SPO was bound." 1181 << tcu::TestLog::EndMessage; 1182 1183 result = false; 1184 } 1185 1186 end: 1187 if (result) 1188 { 1189 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1190 } 1191 else 1192 { 1193 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1194 } 1195 1196 return STOP; 1197 } 1198 1199 /** Constructor 1200 * 1201 * @param context Test context 1202 * @param extParams Not used. 1203 * @param name Test case's name 1204 * @param description Test case's description 1205 **/ 1206 GeometryShaderDrawCallWithFSAndGS::GeometryShaderDrawCallWithFSAndGS(Context& context, const ExtParameters& extParams, 1207 const char* name, const char* description) 1208 : TestCaseBase(context, extParams, name, description) 1209 , m_fs_po_id(0) 1210 , m_gs_po_id(0) 1211 , m_pipeline_object_id(0) 1212 , m_vao_id(0) 1213 { 1214 } 1215 1216 /** Deinitializes GLES objects created during the test. */ 1217 void GeometryShaderDrawCallWithFSAndGS::deinit() 1218 { 1219 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1220 1221 if (m_fs_po_id != 0) 1222 { 1223 gl.deleteProgram(m_fs_po_id); 1224 1225 m_fs_po_id = 0; 1226 } 1227 1228 if (m_gs_po_id != 0) 1229 { 1230 gl.deleteProgram(m_gs_po_id); 1231 1232 m_gs_po_id = 0; 1233 } 1234 1235 if (m_pipeline_object_id != 0) 1236 { 1237 gl.deleteProgramPipelines(1, &m_pipeline_object_id); 1238 1239 m_pipeline_object_id = 0; 1240 } 1241 1242 if (m_vao_id != 0) 1243 { 1244 gl.deleteVertexArrays(1, &m_vao_id); 1245 1246 m_vao_id = 0; 1247 } 1248 1249 /* Release base class */ 1250 TestCaseBase::deinit(); 1251 } 1252 1253 /** Executes the test. 1254 * 1255 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 1256 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 1257 * Note the function throws exception should an error occur! 1258 **/ 1259 tcu::TestNode::IterateResult GeometryShaderDrawCallWithFSAndGS::iterate() 1260 { 1261 glw::GLenum error_code = GL_NO_ERROR; 1262 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1263 bool result = true; 1264 1265 /* This test should only run if EXT_geometry_shader is supported. */ 1266 if (!m_is_geometry_shader_extension_supported) 1267 { 1268 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 1269 } 1270 1271 /* Create & bind a VAO */ 1272 gl.genVertexArrays(1, &m_vao_id); 1273 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 1274 1275 gl.bindVertexArray(m_vao_id); 1276 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 1277 1278 /* Create shader program objects */ 1279 std::string code_fs_specialized = specializeShader(1, /* parts */ 1280 &dummy_fs_code); 1281 const char* code_fs_specialized_raw = code_fs_specialized.c_str(); 1282 std::string code_gs_specialized = specializeShader(1, /* parts */ 1283 &dummy_gs_code); 1284 const char* code_gs_specialized_raw = code_gs_specialized.c_str(); 1285 glw::GLint link_status = GL_FALSE; 1286 1287 m_fs_po_id = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1, /* count */ 1288 &code_fs_specialized_raw); 1289 m_gs_po_id = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1, /* count */ 1290 &code_gs_specialized_raw); 1291 1292 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call(s) failed."); 1293 1294 gl.getProgramiv(m_fs_po_id, GL_LINK_STATUS, &link_status); 1295 1296 if (link_status != GL_TRUE) 1297 { 1298 m_testCtx.getLog() << tcu::TestLog::Message << "Dummy fragment shader program failed to link." 1299 << tcu::TestLog::EndMessage; 1300 1301 result = false; 1302 goto end; 1303 } 1304 1305 gl.getProgramiv(m_gs_po_id, GL_LINK_STATUS, &link_status); 1306 1307 if (link_status != GL_TRUE) 1308 { 1309 m_testCtx.getLog() << tcu::TestLog::Message << "Dummy geometry shader program failed to link." 1310 << tcu::TestLog::EndMessage; 1311 1312 result = false; 1313 goto end; 1314 } 1315 1316 /* Create & set up a pipeline object */ 1317 gl.genProgramPipelines(1, &m_pipeline_object_id); 1318 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); 1319 1320 gl.useProgramStages(m_pipeline_object_id, GL_FRAGMENT_SHADER_BIT, m_fs_po_id); 1321 gl.useProgramStages(m_pipeline_object_id, GL_GEOMETRY_SHADER_BIT, m_gs_po_id); 1322 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call(s) failed."); 1323 1324 gl.bindProgramPipeline(m_pipeline_object_id); 1325 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 1326 1327 /* Try to do a draw call */ 1328 gl.drawArrays(GL_POINTS, 0, /* first */ 1329 1); /* count */ 1330 1331 error_code = gl.getError(); 1332 if (error_code != GL_INVALID_OPERATION) 1333 { 1334 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid draw call generated an error code [" << error_code 1335 << "]" 1336 " which is different from the expected GL_INVALID_OPERATION." 1337 << tcu::TestLog::EndMessage; 1338 1339 result = false; 1340 } 1341 1342 end: 1343 // m_pipeline_object_id is generated in this function, need to be freed 1344 if (m_pipeline_object_id) 1345 { 1346 gl.deleteProgramPipelines(1, &m_pipeline_object_id); 1347 m_pipeline_object_id = 0; 1348 } 1349 1350 // m_gs_po_id is generated in this function, need to be freed 1351 if (m_gs_po_id) 1352 { 1353 gl.deleteProgram(m_gs_po_id); 1354 m_gs_po_id = 0; 1355 } 1356 1357 // m_fs_po_id is generated in this function, need to be freed 1358 if (m_fs_po_id) 1359 { 1360 gl.deleteProgram(m_fs_po_id); 1361 m_fs_po_id = 0; 1362 } 1363 1364 // m_vao_id is generated in this function, need to be freed 1365 if (m_vao_id) 1366 { 1367 gl.deleteVertexArrays(1, &m_vao_id); 1368 m_vao_id = 0; 1369 } 1370 1371 /* All done */ 1372 if (result) 1373 { 1374 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1375 } 1376 else 1377 { 1378 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1379 } 1380 1381 return STOP; 1382 } 1383 1384 /** Constructor 1385 * 1386 * @param context Test context 1387 * @param extParams Not used. 1388 * @param name Test case's name 1389 * @param description Test case's description 1390 **/ 1391 GeometryShaderMaxImageUniformsTest::GeometryShaderMaxImageUniformsTest(Context& context, const ExtParameters& extParams, 1392 const char* name, const char* description) 1393 : TestCaseBase(context, extParams, name, description) 1394 , m_fs_id(0) 1395 , m_gl_max_geometry_image_uniforms_ext_value(0) 1396 , m_gs_id(0) 1397 , m_po_id(0) 1398 , m_texture_ids(NULL) 1399 , m_tfbo_id(0) 1400 , m_vao_id(0) 1401 , m_vs_id(0) 1402 { 1403 //Bug-15063 Only GLSL 4.50 supports opaque types 1404 if (m_glslVersion >= glu::GLSL_VERSION_130) 1405 { 1406 m_glslVersion = glu::GLSL_VERSION_450; 1407 } 1408 } 1409 1410 /** Deinitializes GLES objects created during the test. */ 1411 void GeometryShaderMaxImageUniformsTest::deinit() 1412 { 1413 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1414 1415 if (m_fs_id != 0) 1416 { 1417 gl.deleteShader(m_fs_id); 1418 1419 m_fs_id = 0; 1420 } 1421 1422 if (m_gs_id != 0) 1423 { 1424 gl.deleteShader(m_gs_id); 1425 1426 m_gs_id = 0; 1427 } 1428 1429 if (m_po_id != 0) 1430 { 1431 gl.deleteProgram(m_po_id); 1432 1433 m_po_id = 0; 1434 } 1435 1436 if (m_texture_ids != NULL) 1437 { 1438 gl.deleteTextures(m_gl_max_geometry_image_uniforms_ext_value, m_texture_ids); 1439 1440 delete[] m_texture_ids; 1441 m_texture_ids = NULL; 1442 } 1443 1444 if (m_tfbo_id != 0) 1445 { 1446 gl.deleteBuffers(1, &m_tfbo_id); 1447 m_tfbo_id = 0; 1448 } 1449 1450 if (m_vao_id != 0) 1451 { 1452 gl.deleteVertexArrays(1, &m_vao_id); 1453 m_vao_id = 0; 1454 } 1455 1456 if (m_vs_id != 0) 1457 { 1458 gl.deleteShader(m_vs_id); 1459 1460 m_vs_id = 0; 1461 } 1462 1463 /* Set GL_PACK_ALIGNMENT to default value. */ 1464 gl.pixelStorei(GL_PACK_ALIGNMENT, 4 /*default value taken from specification*/); 1465 GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed for GL_PACK_ALIGNMENT pname."); 1466 1467 /* Release base class */ 1468 TestCaseBase::deinit(); 1469 } 1470 1471 /* Retrieves test-specific geometry shader source code. 1472 * 1473 * @return Requested string. 1474 */ 1475 std::string GeometryShaderMaxImageUniformsTest::getGSCode() 1476 { 1477 std::stringstream code_sstream; 1478 1479 /* Form the GS */ 1480 code_sstream << "${VERSION}\n" 1481 "${GEOMETRY_SHADER_REQUIRE}\n" 1482 "\n" 1483 "layout (points) in;\n" 1484 "layout (points, max_vertices = 1) out;\n" 1485 "\n" 1486 "precision highp iimage2D;\n" 1487 "\n" 1488 "ivec4 counter = ivec4(0);\n" 1489 "\n"; 1490 1491 for (glw::GLint n_img = 0; n_img < (m_gl_max_geometry_image_uniforms_ext_value); ++n_img) 1492 { 1493 code_sstream << "layout(binding = " << n_img << ", r32i) uniform iimage2D img" << n_img << ";\n"; 1494 } 1495 1496 code_sstream << "\n" 1497 "void main()\n" 1498 "{\n"; 1499 1500 for (glw::GLint n_img = 0; n_img < (m_gl_max_geometry_image_uniforms_ext_value); ++n_img) 1501 { 1502 code_sstream << " counter += imageLoad(img" << n_img << ", ivec2(0, 0));\n"; 1503 } 1504 1505 code_sstream << "\n" 1506 " gl_Position = vec4(float(counter.x), 0.0, 0.0, 1.0);\n" 1507 " EmitVertex();\n" 1508 "}\n"; 1509 1510 /* Form a specialized version of the GS source code */ 1511 std::string gs_code = code_sstream.str(); 1512 const char* gs_code_raw = gs_code.c_str(); 1513 std::string gs_code_specialized = specializeShader(1 /* parts */, &gs_code_raw); 1514 1515 return gs_code_specialized; 1516 } 1517 1518 /** Executes the test. 1519 * 1520 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 1521 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 1522 * Note the function throws exception should an error occur! 1523 **/ 1524 tcu::TestNode::IterateResult GeometryShaderMaxImageUniformsTest::iterate() 1525 { 1526 glw::GLint counter = 0; 1527 glw::GLint expectedValue = 0; 1528 bool has_shader_compilation_failed = true; 1529 glw::GLfloat* ptr = DE_NULL; 1530 bool result = true; 1531 const glw::GLchar* feedbackVaryings[] = { "gl_Position" }; 1532 1533 std::string fs_code_specialized = ""; 1534 const char* fs_code_specialized_raw = DE_NULL; 1535 std::string gs_code_specialized = ""; 1536 const char* gs_code_specialized_raw = DE_NULL; 1537 std::string vs_code_specialized = ""; 1538 const char* vs_code_specialized_raw = DE_NULL; 1539 1540 /* This test should only run if EXT_geometry_shader is supported. */ 1541 if (!m_is_geometry_shader_extension_supported) 1542 { 1543 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 1544 } 1545 1546 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1547 1548 /* Retrieve GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT pname value */ 1549 gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_IMAGE_UNIFORMS, &m_gl_max_geometry_image_uniforms_ext_value); 1550 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT pname"); 1551 1552 /* Retrieve GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT pname value */ 1553 glw::GLint m_gl_max_geometry_texture_image_units_ext_value = 0; 1554 gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &m_gl_max_geometry_texture_image_units_ext_value); 1555 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT pname"); 1556 1557 /* Check if m_gl_max_geometry_image_uniforms_value is less than or equal zero. */ 1558 if (m_gl_max_geometry_image_uniforms_ext_value <= 0) 1559 { 1560 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT query value " 1561 << "[" << m_gl_max_geometry_image_uniforms_ext_value 1562 << "]" 1563 " is less than or equal zero. Image uniforms in Geometry Shader" 1564 " are not supported." 1565 << tcu::TestLog::EndMessage; 1566 1567 if (m_gl_max_geometry_image_uniforms_ext_value == 0) 1568 { 1569 throw tcu::NotSupportedError("GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT is 0"); 1570 } 1571 else 1572 { 1573 result = false; 1574 goto end; 1575 } 1576 } 1577 1578 /* Check if m_gl_max_geometry_texture_image_units_value is less than m_gl_max_geometry_image_uniforms_value. */ 1579 if (m_gl_max_geometry_texture_image_units_ext_value < m_gl_max_geometry_image_uniforms_ext_value) 1580 { 1581 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT query value " 1582 << "[" << m_gl_max_geometry_image_uniforms_ext_value 1583 << "]" 1584 " is greater than GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT query value " 1585 "[" 1586 << m_gl_max_geometry_texture_image_units_ext_value << "]." << tcu::TestLog::EndMessage; 1587 1588 result = false; 1589 goto end; 1590 } 1591 1592 /* Create a program object. */ 1593 m_po_id = gl.createProgram(); 1594 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 1595 1596 /* Create shader objects. */ 1597 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 1598 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 1599 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 1600 1601 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 1602 1603 /* Configure which outputs should be captured by Transform Feedback. */ 1604 gl.transformFeedbackVaryings(m_po_id, 1 /* varyings count */, feedbackVaryings, GL_INTERLEAVED_ATTRIBS); 1605 1606 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed."); 1607 1608 /* Try to link the test program object */ 1609 fs_code_specialized = specializeShader(1, &dummy_fs_code); 1610 fs_code_specialized_raw = fs_code_specialized.c_str(); 1611 1612 gs_code_specialized = getGSCode(); 1613 gs_code_specialized_raw = gs_code_specialized.c_str(); 1614 1615 vs_code_specialized = specializeShader(1, &dummy_vs_code); 1616 vs_code_specialized_raw = vs_code_specialized.c_str(); 1617 1618 if (!TestCaseBase::buildProgram(m_po_id, m_gs_id, 1, /* n_sh1_body_parts */ 1619 &gs_code_specialized_raw, m_vs_id, 1, /* n_sh2_body_parts */ 1620 &vs_code_specialized_raw, m_fs_id, 1, /* n_sh3_body_parts */ 1621 &fs_code_specialized_raw, &has_shader_compilation_failed)) 1622 { 1623 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed." << tcu::TestLog::EndMessage; 1624 1625 result = false; 1626 goto end; 1627 } 1628 1629 /* Use program. */ 1630 gl.useProgram(m_po_id); 1631 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 1632 1633 /* Allocate memory for m_max_image_units_value Texture Objects. */ 1634 m_texture_ids = new glw::GLuint[m_gl_max_geometry_image_uniforms_ext_value]; 1635 1636 /* Generate m_max_image_units_value Texture Objects. */ 1637 gl.genTextures(m_gl_max_geometry_image_uniforms_ext_value, m_texture_ids); 1638 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); 1639 1640 /* Set GL_PACK_ALIGNMENT to 1. */ 1641 gl.pixelStorei(GL_PACK_ALIGNMENT, 1); 1642 GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed for GL_PACK_ALIGNMENT pname."); 1643 1644 /* Bind integer 2D texture objects of resolution 1x1 to image units. */ 1645 for (glw::GLint n_img = 0; n_img < (m_gl_max_geometry_image_uniforms_ext_value); ++n_img) 1646 { 1647 glw::GLint texture = m_texture_ids[n_img]; 1648 glw::GLint value = n_img + 1; 1649 1650 gl.bindTexture(GL_TEXTURE_2D, texture); 1651 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); 1652 1653 gl.texStorage2D(GL_TEXTURE_2D, 1 /*levels*/, GL_R32I, 1 /*width*/, 1 /*height*/); 1654 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed."); 1655 1656 gl.texSubImage2D(GL_TEXTURE_2D, 0 /*level*/, 0 /*xoffset*/, 0 /*yoffset*/, 1 /*width*/, 1 /*height*/, 1657 GL_RED_INTEGER, GL_INT, &value); 1658 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexSubImage2D() call failed."); 1659 1660 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 1661 GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri() call failed."); 1662 1663 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1664 GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri() call failed."); 1665 1666 gl.bindImageTexture(n_img, texture, 0 /*level*/, GL_FALSE /*is layered?*/, 0 /*layer*/, GL_READ_ONLY, GL_R32I); 1667 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() call failed."); 1668 } 1669 1670 /* Configure VAO. */ 1671 gl.genVertexArrays(1, &m_vao_id); 1672 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 1673 1674 gl.bindVertexArray(m_vao_id); 1675 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 1676 1677 /* Create a Buffer Object for Transform Feedback's outputs. */ 1678 gl.genBuffers(1, &m_tfbo_id); 1679 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 1680 1681 gl.bindBuffer(GL_ARRAY_BUFFER, m_tfbo_id); 1682 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); 1683 1684 gl.bufferData(GL_ARRAY_BUFFER, sizeof(glw::GLfloat) * 4 /* four float vector components */, NULL, GL_STATIC_READ); 1685 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 1686 1687 /* Bind Buffer Object m_tfbo_id to GL_TRANSFORM_FEEDBACK_BUFFER binding point. */ 1688 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_tfbo_id); 1689 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); 1690 1691 /* Disable rasterization and make a draw call. After that, turn on rasterization. */ 1692 gl.enable(GL_RASTERIZER_DISCARD); 1693 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable() call failed for GL_RASTERIZER_DISCARD pname."); 1694 1695 gl.beginTransformFeedback(GL_POINTS); 1696 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); 1697 1698 gl.drawArrays(GL_POINTS, 0 /*starting index*/, 1 /*number of indices*/); 1699 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed for GL_POINTS pname."); 1700 1701 gl.endTransformFeedback(); 1702 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); 1703 1704 gl.disable(GL_RASTERIZER_DISCARD); 1705 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable() call failed for GL_RASTERIZER_DISCARD pname."); 1706 1707 /* Retrieve value from Transform Feedback. */ 1708 counter = 0; 1709 ptr = (glw::GLfloat*)gl.mapBufferRange( 1710 GL_ARRAY_BUFFER, 0, sizeof(glw::GLfloat) * 4 /* four float vector components */, GL_MAP_READ_BIT); 1711 1712 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 1713 1714 counter = int(ptr[0] + 0.5f); 1715 1716 gl.unmapBuffer(GL_ARRAY_BUFFER); 1717 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 1718 1719 /* Calculate expected value. */ 1720 expectedValue = m_gl_max_geometry_image_uniforms_ext_value * (m_gl_max_geometry_image_uniforms_ext_value + 1) / 2; 1721 1722 if (counter != expectedValue) 1723 { 1724 result = false; 1725 } 1726 1727 end: 1728 if (result) 1729 { 1730 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1731 } 1732 else 1733 { 1734 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1735 } 1736 1737 return STOP; 1738 } 1739 1740 /** Constructor 1741 * 1742 * @param context Test context 1743 * @param extParams Not used. 1744 * @param name Test case's name 1745 * @param description Test case's description 1746 **/ 1747 GeometryShaderMaxShaderStorageBlocksTest::GeometryShaderMaxShaderStorageBlocksTest(Context& context, 1748 const ExtParameters& extParams, 1749 const char* name, 1750 const char* description) 1751 : TestCaseBase(context, extParams, name, description) 1752 , m_fs_id(0) 1753 , m_gl_max_geometry_shader_storage_blocks_ext_value(0) 1754 , m_gs_id(0) 1755 , m_po_id(0) 1756 , m_ssbo_id(0) 1757 , m_tfbo_id(0) 1758 , m_vao_id(0) 1759 , m_vs_id(0) 1760 { 1761 } 1762 1763 /** Deinitializes GLES objects created during the test. */ 1764 void GeometryShaderMaxShaderStorageBlocksTest::deinit() 1765 { 1766 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1767 1768 if (m_fs_id != 0) 1769 { 1770 gl.deleteShader(m_fs_id); 1771 m_fs_id = 0; 1772 } 1773 1774 if (m_gs_id != 0) 1775 { 1776 gl.deleteShader(m_gs_id); 1777 m_gs_id = 0; 1778 } 1779 1780 if (m_po_id != 0) 1781 { 1782 gl.deleteProgram(m_po_id); 1783 m_po_id = 0; 1784 } 1785 1786 if (m_ssbo_id != 0) 1787 { 1788 gl.deleteBuffers(1, &m_ssbo_id); 1789 m_ssbo_id = 0; 1790 } 1791 1792 if (m_tfbo_id != 0) 1793 { 1794 gl.deleteBuffers(1, &m_tfbo_id); 1795 m_tfbo_id = 0; 1796 } 1797 1798 if (m_vao_id != 0) 1799 { 1800 gl.deleteVertexArrays(1, &m_vao_id); 1801 m_vao_id = 0; 1802 } 1803 1804 if (m_vs_id != 0) 1805 { 1806 gl.deleteShader(m_vs_id); 1807 m_vs_id = 0; 1808 } 1809 1810 /* Release base class */ 1811 TestCaseBase::deinit(); 1812 } 1813 1814 /* Retrieves test-specific geometry shader source code. 1815 * 1816 * @return Requested string. 1817 */ 1818 std::string GeometryShaderMaxShaderStorageBlocksTest::getGSCode() 1819 { 1820 std::stringstream code_sstream; 1821 1822 /* Form the GS */ 1823 code_sstream << "${VERSION}\n" 1824 "${GEOMETRY_SHADER_REQUIRE}\n" 1825 "\n" 1826 "layout (points) in;\n" 1827 "layout (points, max_vertices = 1) out;\n" 1828 "\n" 1829 "int counter = 0;\n" 1830 "\n"; 1831 1832 for (glw::GLint n_ssb = 0; n_ssb < (m_gl_max_geometry_shader_storage_blocks_ext_value); ++n_ssb) 1833 { 1834 code_sstream << "layout(binding = " << n_ssb << ") buffer ssb" << n_ssb << " \n{\n" 1835 << " int value;\n" 1836 << "} S_SSB" << n_ssb << ";\n\n"; 1837 } 1838 1839 code_sstream << "\n" 1840 "void main()\n" 1841 "{\n"; 1842 1843 for (glw::GLint n_ssb = 0; n_ssb < (m_gl_max_geometry_shader_storage_blocks_ext_value); ++n_ssb) 1844 { 1845 code_sstream << " counter += S_SSB" << n_ssb << ".value++;\n"; 1846 } 1847 1848 code_sstream << "\n" 1849 " gl_Position = vec4(float(counter), 0.0, 0.0, 1.0);\n" 1850 " EmitVertex();\n" 1851 "}\n"; 1852 1853 /* Form a specialized version of the GS source code */ 1854 std::string gs_code = code_sstream.str(); 1855 const char* gs_code_raw = gs_code.c_str(); 1856 std::string gs_code_specialized = specializeShader(1 /* parts */, &gs_code_raw); 1857 1858 return gs_code_specialized; 1859 } 1860 1861 /** Executes the test. 1862 * 1863 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 1864 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 1865 * Note the function throws exception should an error occur! 1866 **/ 1867 tcu::TestNode::IterateResult GeometryShaderMaxShaderStorageBlocksTest::iterate() 1868 { 1869 glw::GLint counter = 0; 1870 glw::GLint expectedValue = 0; 1871 const glw::GLchar* feedbackVaryings[] = { "gl_Position" }; 1872 bool has_shader_compilation_failed = true; 1873 const glw::GLfloat initial_buffer_data[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; 1874 glw::GLint int_alignment = 0; 1875 const glw::GLint int_size = sizeof(glw::GLint); 1876 glw::GLint* ptrSSBO_data = DE_NULL; 1877 glw::GLfloat* ptrTF_data = DE_NULL; 1878 bool result = true; 1879 glw::GLint ssbo_alignment = 0; 1880 glw::GLint* ssbo_data = DE_NULL; 1881 glw::GLint ssbo_data_size = 0; 1882 1883 std::string fs_code_specialized = ""; 1884 const char* fs_code_specialized_raw = DE_NULL; 1885 std::string gs_code_specialized = ""; 1886 const char* gs_code_specialized_raw = DE_NULL; 1887 std::string vs_code_specialized = ""; 1888 const char* vs_code_specialized_raw = DE_NULL; 1889 1890 /* This test should only run if EXT_geometry_shader is supported. */ 1891 if (!m_is_geometry_shader_extension_supported) 1892 { 1893 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 1894 } 1895 1896 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1897 1898 /* Retrieve GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT pname value */ 1899 gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_SHADER_STORAGE_BLOCKS, 1900 &m_gl_max_geometry_shader_storage_blocks_ext_value); 1901 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT pname"); 1902 1903 /* Retrieve GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS pname value */ 1904 glw::GLint m_gl_max_shader_storage_buffer_bindings_value = 0; 1905 1906 gl.getIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &m_gl_max_shader_storage_buffer_bindings_value); 1907 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS pname"); 1908 1909 /* Check if m_gl_max_shader_storage_blocks_value is less than or equal zero. */ 1910 if (m_gl_max_geometry_shader_storage_blocks_ext_value <= 0) 1911 { 1912 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT query value " 1913 << "[" << m_gl_max_geometry_shader_storage_blocks_ext_value 1914 << "]" 1915 " is less than or equal zero. Shader Storage Blocks" 1916 " in Geometry Shader are not supported." 1917 << tcu::TestLog::EndMessage; 1918 1919 if (m_gl_max_geometry_shader_storage_blocks_ext_value == 0) 1920 { 1921 throw tcu::NotSupportedError("GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT is 0"); 1922 } 1923 else 1924 { 1925 result = false; 1926 goto end; 1927 } 1928 } 1929 1930 /* Check if m_gl_max_shader_storage_buffer_bindings_value is less than m_gl_max_shader_storage_blocks_value. */ 1931 if (m_gl_max_shader_storage_buffer_bindings_value < m_gl_max_geometry_shader_storage_blocks_ext_value) 1932 { 1933 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT query value " 1934 << "[" << m_gl_max_geometry_shader_storage_blocks_ext_value 1935 << "]" 1936 " is greater than GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS query value " 1937 "[" 1938 << m_gl_max_shader_storage_buffer_bindings_value << "]." << tcu::TestLog::EndMessage; 1939 1940 result = false; 1941 goto end; 1942 } 1943 1944 /* Create a program object. */ 1945 m_po_id = gl.createProgram(); 1946 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 1947 1948 /* Create shader objects. */ 1949 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 1950 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 1951 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 1952 1953 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 1954 1955 /* Configure which outputs should be captured by Transform Feedback. */ 1956 gl.transformFeedbackVaryings(m_po_id, 1 /* varyings count */, feedbackVaryings, GL_INTERLEAVED_ATTRIBS); 1957 1958 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed."); 1959 1960 /* Try to link the test program object */ 1961 fs_code_specialized = specializeShader(1, &dummy_fs_code); 1962 fs_code_specialized_raw = fs_code_specialized.c_str(); 1963 1964 gs_code_specialized = getGSCode(); 1965 gs_code_specialized_raw = gs_code_specialized.c_str(); 1966 1967 vs_code_specialized = specializeShader(1, &dummy_vs_code); 1968 vs_code_specialized_raw = vs_code_specialized.c_str(); 1969 1970 if (!TestCaseBase::buildProgram(m_po_id, m_gs_id, 1, /* n_sh1_body_parts */ 1971 &gs_code_specialized_raw, m_vs_id, 1, /* n_sh2_body_parts */ 1972 &vs_code_specialized_raw, m_fs_id, 1, /* n_sh3_body_parts */ 1973 &fs_code_specialized_raw, &has_shader_compilation_failed)) 1974 { 1975 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed." << tcu::TestLog::EndMessage; 1976 1977 result = false; 1978 goto end; 1979 } 1980 1981 /* Prepare data for Shader Storage Buffer Object. */ 1982 gl.getIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &ssbo_alignment); 1983 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed."); 1984 1985 int_alignment = ssbo_alignment / int_size; 1986 ssbo_data_size = m_gl_max_geometry_shader_storage_blocks_ext_value * ssbo_alignment; 1987 ssbo_data = new glw::GLint[ssbo_data_size]; 1988 1989 if ((ssbo_alignment % int_size) != 0) 1990 { 1991 m_testCtx.getLog() << tcu::TestLog::Message << "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT query value " 1992 "[" 1993 << ssbo_alignment << "]" 1994 "divide with remainder by the size of GLint " 1995 "[" 1996 << int_size << "]" << tcu::TestLog::EndMessage; 1997 1998 result = false; 1999 goto end; 2000 } 2001 2002 for (int i = 0; i < m_gl_max_geometry_shader_storage_blocks_ext_value; ++i) 2003 { 2004 ssbo_data[i * int_alignment] = i + 1; 2005 } 2006 2007 /* Create Shader Storage Buffer Object. */ 2008 gl.genBuffers(1, &m_ssbo_id); 2009 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 2010 2011 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, m_ssbo_id); 2012 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed for GL_SHADER_STORAGE_BUFFER pname."); 2013 2014 gl.bufferData(GL_SHADER_STORAGE_BUFFER, ssbo_data_size, ssbo_data, GL_DYNAMIC_COPY); 2015 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 2016 2017 /* Free unused memory. */ 2018 delete[] ssbo_data; 2019 ssbo_data = NULL; 2020 2021 /* Bind specific m_ssbo_id buffer region to a specific Shader Storage Buffer binding point. */ 2022 for (glw::GLint n_ssb = 0; n_ssb < (m_gl_max_geometry_shader_storage_blocks_ext_value); ++n_ssb) 2023 { 2024 glw::GLuint offset = n_ssb * ssbo_alignment; 2025 2026 gl.bindBufferRange(GL_SHADER_STORAGE_BUFFER, n_ssb /*binding index*/, m_ssbo_id, offset, int_size); 2027 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferRange() call failed."); 2028 } 2029 2030 /* Configure VAO. */ 2031 gl.genVertexArrays(1, &m_vao_id); 2032 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 2033 2034 gl.bindVertexArray(m_vao_id); 2035 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 2036 2037 /* Create a Buffer Object for Transform Feedback's outputs. */ 2038 gl.genBuffers(1, &m_tfbo_id); 2039 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 2040 2041 gl.bindBuffer(GL_ARRAY_BUFFER, m_tfbo_id); 2042 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); 2043 2044 gl.bufferData(GL_ARRAY_BUFFER, sizeof(glw::GLfloat) * 4 /* four float vector components */, initial_buffer_data, 2045 GL_STATIC_READ); 2046 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 2047 2048 /* Bind Buffer Object m_tfbo_id to GL_TRANSFORM_FEEDBACK_BUFFER binding point. */ 2049 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /*binding index*/, m_tfbo_id); 2050 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); 2051 2052 /* Use program. */ 2053 gl.useProgram(m_po_id); 2054 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 2055 2056 /* Disable rasterization and make a draw call. After that, turn on rasterization. */ 2057 gl.enable(GL_RASTERIZER_DISCARD); 2058 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable() call failed for GL_RASTERIZER_DISCARD pname."); 2059 2060 gl.beginTransformFeedback(GL_POINTS); 2061 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); 2062 2063 gl.drawArrays(GL_POINTS, 0 /*starting index*/, 1 /*number of indices*/); 2064 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed for GL_POINTS pname."); 2065 2066 gl.endTransformFeedback(); 2067 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); 2068 2069 gl.disable(GL_RASTERIZER_DISCARD); 2070 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable() call failed for GL_RASTERIZER_DISCARD pname."); 2071 2072 /* Retrieve value from Transform Feedback. */ 2073 ptrTF_data = (glw::GLfloat*)gl.mapBufferRange( 2074 GL_ARRAY_BUFFER, 0 /*offset*/, sizeof(glw::GLfloat) * 4 /* four float vector components */, GL_MAP_READ_BIT); 2075 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 2076 2077 counter = int(ptrTF_data[0] + 0.5f); 2078 2079 gl.unmapBuffer(GL_ARRAY_BUFFER); 2080 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 2081 2082 ptrTF_data = NULL; 2083 2084 /* Retrieve values from Shader Storage Buffer Object. */ 2085 ptrSSBO_data = 2086 (glw::GLint*)gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0 /*offset*/, ssbo_data_size, GL_MAP_READ_BIT); 2087 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 2088 2089 for (int i = 0; i < m_gl_max_geometry_shader_storage_blocks_ext_value; ++i) 2090 { 2091 if (ptrSSBO_data[i * int_alignment] != i + 2) 2092 { 2093 result = false; 2094 2095 m_testCtx.getLog() << tcu::TestLog::Message << "Value read from Shader Storage Buffer " 2096 "[" 2097 << ptrSSBO_data[i * int_alignment] << "] " 2098 "at index " 2099 "[" 2100 << i * int_alignment << "]" 2101 "is not equal to expected value " 2102 "[" 2103 << i + 2 << "]" << tcu::TestLog::EndMessage; 2104 2105 break; 2106 } 2107 } 2108 2109 gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); 2110 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 2111 2112 ptrSSBO_data = NULL; 2113 2114 /* Calculate expected value. */ 2115 expectedValue = 2116 m_gl_max_geometry_shader_storage_blocks_ext_value * (m_gl_max_geometry_shader_storage_blocks_ext_value + 1) / 2; 2117 2118 if (counter != expectedValue) 2119 { 2120 result = false; 2121 } 2122 2123 end: 2124 if (result) 2125 { 2126 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2127 } 2128 else 2129 { 2130 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2131 } 2132 2133 return STOP; 2134 } 2135 2136 /** Constructor 2137 * 2138 * @param context Test context 2139 * @param extParams Not used. 2140 * @param name Test case's name 2141 * @param description Test case's description 2142 **/ 2143 GeometryShaderMaxAtomicCountersTest::GeometryShaderMaxAtomicCountersTest(Context& context, 2144 const ExtParameters& extParams, 2145 const char* name, const char* description) 2146 : TestCaseBase(context, extParams, name, description) 2147 , m_acbo_id(0) 2148 , m_fs_id(0) 2149 , m_gl_max_geometry_atomic_counters_ext_value(0) 2150 , m_gs_id(0) 2151 , m_po_id(0) 2152 , m_vao_id(0) 2153 , m_vs_id(0) 2154 { 2155 } 2156 2157 /** Deinitializes GLES objects created during the test. */ 2158 void GeometryShaderMaxAtomicCountersTest::deinit() 2159 { 2160 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2161 2162 if (m_acbo_id != 0) 2163 { 2164 gl.deleteBuffers(1, &m_acbo_id); 2165 m_acbo_id = 0; 2166 } 2167 2168 if (m_fs_id != 0) 2169 { 2170 gl.deleteShader(m_fs_id); 2171 m_fs_id = 0; 2172 } 2173 2174 if (m_gs_id != 0) 2175 { 2176 gl.deleteShader(m_gs_id); 2177 m_gs_id = 0; 2178 } 2179 2180 if (m_po_id != 0) 2181 { 2182 gl.deleteProgram(m_po_id); 2183 m_po_id = 0; 2184 } 2185 2186 if (m_vao_id != 0) 2187 { 2188 gl.deleteVertexArrays(1, &m_vao_id); 2189 m_vao_id = 0; 2190 } 2191 2192 if (m_vs_id != 0) 2193 { 2194 gl.deleteShader(m_vs_id); 2195 m_vs_id = 0; 2196 } 2197 2198 /* Release base class */ 2199 TestCaseBase::deinit(); 2200 } 2201 2202 /* Retrieves test-specific geometry shader source code. 2203 * 2204 * @return Requested string. 2205 */ 2206 std::string GeometryShaderMaxAtomicCountersTest::getGSCode() 2207 { 2208 std::stringstream code_sstream; 2209 2210 /* Form the GS */ 2211 code_sstream << "${VERSION}\n" 2212 "${GEOMETRY_SHADER_REQUIRE}\n" 2213 "\n" 2214 "layout (points) in;\n" 2215 "layout (points, max_vertices = 1) out;\n" 2216 "\n" 2217 "uniform int n_loop_iterations;\n" 2218 "flat in int vertex_id[];\n" 2219 "\n"; 2220 2221 code_sstream << "layout(binding = 0) uniform atomic_uint acs[" << m_gl_max_geometry_atomic_counters_ext_value 2222 << "];\n" 2223 << "\n" 2224 "void main()\n" 2225 "{\n" 2226 " for (int counter_id = 1;\n" 2227 " counter_id <= n_loop_iterations;\n" 2228 " ++counter_id)\n" 2229 " {\n" 2230 " if ((vertex_id[0] % counter_id) == 0)\n" 2231 " {\n" 2232 " atomicCounterIncrement(acs[counter_id - 1]);\n" 2233 " }\n" 2234 " }\n" 2235 "\n" 2236 " gl_Position = vec4(1.0, 0.0, 0.0, 1.0);\n" 2237 " EmitVertex();\n" 2238 "}\n"; 2239 2240 /* Form a specialized version of the GS source code */ 2241 std::string gs_code = code_sstream.str(); 2242 const char* gs_code_raw = gs_code.c_str(); 2243 std::string gs_code_specialized = specializeShader(1, /* parts */ &gs_code_raw); 2244 2245 return gs_code_specialized; 2246 } 2247 2248 /** Executes the test. 2249 * 2250 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 2251 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 2252 * Note the function throws exception should an error occur! 2253 **/ 2254 tcu::TestNode::IterateResult GeometryShaderMaxAtomicCountersTest::iterate() 2255 { 2256 /* Define Vertex Shader's code for the purpose of this test. */ 2257 const char* vs_code = "${VERSION}\n" 2258 "\n" 2259 "flat out int vertex_id;\n" 2260 "\n" 2261 "void main()\n" 2262 "{\n" 2263 " vertex_id = gl_VertexID;\n" 2264 " gl_Position = vec4(1.0, 0.0, 0.0, 1.0);\n" 2265 "}\n"; 2266 2267 bool has_shader_compilation_failed = true; 2268 glw::GLuint* initial_ac_data = DE_NULL; 2269 const unsigned int n_draw_call_vertices = 4; 2270 glw::GLint n_loop_iterations_uniform_location = -1; 2271 glw::GLuint* ptrACBO_data = DE_NULL; 2272 bool result = true; 2273 2274 std::string fs_code_specialized = ""; 2275 const char* fs_code_specialized_raw = DE_NULL; 2276 std::string gs_code_specialized = ""; 2277 const char* gs_code_specialized_raw = DE_NULL; 2278 std::string vs_code_specialized = ""; 2279 const char* vs_code_specialized_raw = DE_NULL; 2280 2281 /* This test should only run if EXT_geometry_shader is supported. */ 2282 if (!m_is_geometry_shader_extension_supported) 2283 { 2284 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 2285 } 2286 2287 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2288 2289 /* Retrieve GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT pname value */ 2290 gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_ATOMIC_COUNTERS, &m_gl_max_geometry_atomic_counters_ext_value); 2291 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT pname"); 2292 2293 /* Check if m_gl_max_atomic_counters_value is less than or equal zero. */ 2294 if (m_gl_max_geometry_atomic_counters_ext_value <= 0) 2295 { 2296 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT query value " 2297 << "[" << m_gl_max_geometry_atomic_counters_ext_value 2298 << "]" 2299 " is less than or equal to zero. Atomic Counters" 2300 " in Geometry Shader are not supported." 2301 << tcu::TestLog::EndMessage; 2302 2303 if (m_gl_max_geometry_atomic_counters_ext_value == 0) 2304 { 2305 throw tcu::NotSupportedError("GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT is 0"); 2306 } 2307 else 2308 { 2309 result = false; 2310 goto end; 2311 } 2312 } 2313 2314 /* Create a program object. */ 2315 m_po_id = gl.createProgram(); 2316 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 2317 2318 /* Create shader objects. */ 2319 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 2320 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 2321 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 2322 2323 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 2324 2325 /* Try to link the test program object */ 2326 fs_code_specialized = specializeShader(1, &dummy_fs_code); 2327 fs_code_specialized_raw = fs_code_specialized.c_str(); 2328 2329 gs_code_specialized = getGSCode(); 2330 gs_code_specialized_raw = gs_code_specialized.c_str(); 2331 2332 vs_code_specialized = specializeShader(1, &vs_code); 2333 vs_code_specialized_raw = vs_code_specialized.c_str(); 2334 2335 if (!TestCaseBase::buildProgram(m_po_id, m_gs_id, 1, /* n_sh1_body_parts */ 2336 &gs_code_specialized_raw, m_vs_id, 1, /* n_sh2_body_parts */ 2337 &vs_code_specialized_raw, m_fs_id, 1, /* n_sh3_body_parts */ 2338 &fs_code_specialized_raw, &has_shader_compilation_failed)) 2339 { 2340 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed." << tcu::TestLog::EndMessage; 2341 2342 result = false; 2343 goto end; 2344 } 2345 2346 /* Create Atomic Counter Buffer Objects. */ 2347 gl.genBuffers(1, &m_acbo_id); 2348 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 2349 2350 /* Prepare initial data - zeroes - to fill the Atomic Counter Buffer Object. */ 2351 initial_ac_data = new glw::GLuint[m_gl_max_geometry_atomic_counters_ext_value]; 2352 memset(initial_ac_data, 0, sizeof(glw::GLuint) * m_gl_max_geometry_atomic_counters_ext_value); 2353 2354 gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_acbo_id); 2355 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed for GL_SHADER_STORAGE_BUFFER pname."); 2356 2357 gl.bufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(glw::GLuint) * m_gl_max_geometry_atomic_counters_ext_value, NULL, 2358 GL_DYNAMIC_COPY); 2359 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 2360 2361 gl.bufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0 /*offset*/, 2362 sizeof(glw::GLuint) * m_gl_max_geometry_atomic_counters_ext_value, 2363 initial_ac_data /*initialize with zeroes*/); 2364 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferSubData() call failed."); 2365 2366 gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0 /*binding index*/, m_acbo_id /*buffer*/); 2367 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferRange() call failed."); 2368 2369 /* Configure VAO. */ 2370 gl.genVertexArrays(1, &m_vao_id); 2371 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 2372 2373 gl.bindVertexArray(m_vao_id); 2374 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 2375 2376 /* Use program. */ 2377 n_loop_iterations_uniform_location = gl.getUniformLocation(m_po_id, "n_loop_iterations"); 2378 2379 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() call failed."); 2380 if (n_loop_iterations_uniform_location == -1) 2381 { 2382 TCU_FAIL("n_loop_iterations uniform is considered inactive"); 2383 } 2384 else 2385 { 2386 gl.useProgram(m_po_id); 2387 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 2388 2389 gl.uniform1i(n_loop_iterations_uniform_location, m_gl_max_geometry_atomic_counters_ext_value); 2390 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() call failed."); 2391 } 2392 2393 /* Issue the draw call */ 2394 gl.drawArrays(GL_POINTS, 0, n_draw_call_vertices); 2395 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed for GL_POINTS pname."); 2396 2397 /* Retrieve values from Atomic Counter Buffer Objects and check if these values are valid. */ 2398 ptrACBO_data = (glw::GLuint*)gl.mapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0 /*offset*/, 2399 sizeof(glw::GLuint) * m_gl_max_geometry_atomic_counters_ext_value, 2400 GL_MAP_READ_BIT); 2401 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 2402 2403 for (glw::GLint n_ac = 0; n_ac < m_gl_max_geometry_atomic_counters_ext_value; ++n_ac) 2404 { 2405 unsigned int expected_value = 0; 2406 2407 for (unsigned int n_draw_call_vertex = 0; n_draw_call_vertex < n_draw_call_vertices; ++n_draw_call_vertex) 2408 { 2409 if ((n_draw_call_vertex % (n_ac + 1)) == 0) 2410 { 2411 ++expected_value; 2412 } 2413 } 2414 2415 if (ptrACBO_data[n_ac] != expected_value) 2416 { 2417 result = false; 2418 break; 2419 } 2420 } 2421 2422 gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER); 2423 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 2424 2425 ptrACBO_data = NULL; 2426 2427 end: 2428 if (result) 2429 { 2430 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2431 } 2432 else 2433 { 2434 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2435 } 2436 2437 return STOP; 2438 } 2439 2440 /** Constructor 2441 * 2442 * @param context Test context 2443 * @param extParams Not used. 2444 * @param name Test case's name 2445 * @param description Test case's description 2446 **/ 2447 GeometryShaderMaxAtomicCounterBuffersTest::GeometryShaderMaxAtomicCounterBuffersTest(Context& context, 2448 const ExtParameters& extParams, 2449 const char* name, 2450 const char* description) 2451 : TestCaseBase(context, extParams, name, description) 2452 , m_acbo_ids(NULL) 2453 , m_fs_id(0) 2454 , m_gl_max_atomic_counter_buffer_bindings_value(0) 2455 , m_gl_max_geometry_atomic_counter_buffers_ext_value(0) 2456 , m_gs_id(0) 2457 , m_po_id(0) 2458 , m_vao_id(0) 2459 , m_vs_id(0) 2460 { 2461 } 2462 2463 /** Deinitializes GLES objects created during the test. */ 2464 void GeometryShaderMaxAtomicCounterBuffersTest::deinit() 2465 { 2466 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2467 2468 if (m_acbo_ids != NULL) 2469 { 2470 if (m_gl_max_geometry_atomic_counter_buffers_ext_value > 0) 2471 { 2472 gl.deleteBuffers(m_gl_max_geometry_atomic_counter_buffers_ext_value, m_acbo_ids); 2473 2474 delete[] m_acbo_ids; 2475 m_acbo_ids = NULL; 2476 } 2477 } 2478 2479 if (m_fs_id != 0) 2480 { 2481 gl.deleteShader(m_fs_id); 2482 m_fs_id = 0; 2483 } 2484 2485 if (m_gs_id != 0) 2486 { 2487 gl.deleteShader(m_gs_id); 2488 m_gs_id = 0; 2489 } 2490 2491 if (m_po_id != 0) 2492 { 2493 gl.deleteProgram(m_po_id); 2494 m_po_id = 0; 2495 } 2496 2497 if (m_vao_id != 0) 2498 { 2499 gl.deleteVertexArrays(1, &m_vao_id); 2500 m_vao_id = 0; 2501 } 2502 2503 if (m_vs_id != 0) 2504 { 2505 gl.deleteShader(m_vs_id); 2506 m_vs_id = 0; 2507 } 2508 2509 /* Release base class */ 2510 TestCaseBase::deinit(); 2511 } 2512 2513 /* Retrieves test-specific geometry shader source code. 2514 * 2515 * @return Requested string. 2516 */ 2517 std::string GeometryShaderMaxAtomicCounterBuffersTest::getGSCode() 2518 { 2519 std::stringstream code_sstream; 2520 2521 /* Form the GS */ 2522 code_sstream << "${VERSION}\n" 2523 "${GEOMETRY_SHADER_REQUIRE}\n" 2524 "\n" 2525 "layout (points) in;\n" 2526 "layout (points, max_vertices = 1) out;\n" 2527 "\n" 2528 "flat in int vertex_id[];\n" 2529 "\n"; 2530 2531 for (glw::GLint n_ac = 0; n_ac < (m_gl_max_geometry_atomic_counter_buffers_ext_value); ++n_ac) 2532 { 2533 code_sstream << "layout(binding = " << n_ac << ") uniform atomic_uint ac" << n_ac << ";\n"; 2534 } 2535 2536 code_sstream << "\n" 2537 "void main()\n" 2538 "{\n" 2539 " for(int counter_id = 1; counter_id <= " 2540 << m_gl_max_geometry_atomic_counter_buffers_ext_value 2541 << "; ++counter_id)\n" 2542 " {\n" 2543 " if((vertex_id[0] % counter_id) == 0)\n" 2544 " {\n"; 2545 2546 for (glw::GLint n_ac = 0; n_ac < (m_gl_max_geometry_atomic_counter_buffers_ext_value); ++n_ac) 2547 { 2548 code_sstream << " atomicCounterIncrement(ac" << n_ac << ");\n"; 2549 } 2550 2551 code_sstream << " }\n" 2552 " }\n"; 2553 2554 code_sstream << "\n" 2555 " gl_Position = vec4(1.0, 0.0, 0.0, 1.0);\n" 2556 " EmitVertex();\n" 2557 "}\n"; 2558 2559 /* Form a specialized version of the GS source code */ 2560 std::string gs_code = code_sstream.str(); 2561 const char* gs_code_raw = gs_code.c_str(); 2562 std::string gs_code_specialized = specializeShader(1, /* parts */ &gs_code_raw); 2563 2564 return gs_code_specialized; 2565 } 2566 2567 /** Executes the test. 2568 * 2569 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 2570 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 2571 * Note the function throws exception should an error occur! 2572 **/ 2573 tcu::TestNode::IterateResult GeometryShaderMaxAtomicCounterBuffersTest::iterate() 2574 { 2575 /* Define Vertex Shader's code for the purpose of this test. */ 2576 const char* vs_code = "${VERSION}\n" 2577 "\n" 2578 "flat out int vertex_id;\n" 2579 "\n" 2580 "void main()\n" 2581 "{\n" 2582 " vertex_id = gl_VertexID;\n" 2583 " gl_Position = vec4(1.0, 0.0, 0.0, 1.0);\n" 2584 "}\n"; 2585 2586 unsigned int expected_value = 0; 2587 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2588 bool has_shader_compilation_failed = true; 2589 const glw::GLuint initial_ac_data = 0; 2590 const glw::GLuint number_of_indices = 128 * m_gl_max_geometry_atomic_counter_buffers_ext_value; 2591 bool result = true; 2592 2593 std::string fs_code_specialized = ""; 2594 const char* fs_code_specialized_raw = DE_NULL; 2595 std::string gs_code_specialized = ""; 2596 const char* gs_code_specialized_raw = DE_NULL; 2597 std::string vs_code_specialized = ""; 2598 const char* vs_code_specialized_raw = DE_NULL; 2599 2600 /* This test should only run if EXT_geometry_shader is supported. */ 2601 if (!m_is_geometry_shader_extension_supported) 2602 { 2603 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 2604 } 2605 2606 /* Retrieve GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT pname value */ 2607 gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS, 2608 &m_gl_max_geometry_atomic_counter_buffers_ext_value); 2609 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT pname"); 2610 2611 /* Retrieve GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS pname value */ 2612 gl.getIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &m_gl_max_atomic_counter_buffer_bindings_value); 2613 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS pname"); 2614 2615 /* Check if m_gl_max_geometry_atomic_counter_buffers_ext_value is less than or equal zero. */ 2616 if (m_gl_max_geometry_atomic_counter_buffers_ext_value <= 0) 2617 { 2618 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT query value " 2619 << "[" << m_gl_max_geometry_atomic_counter_buffers_ext_value 2620 << "]" 2621 " is less than or equal to zero. Atomic Counter Buffers" 2622 " are not supported." 2623 << tcu::TestLog::EndMessage; 2624 2625 if (m_gl_max_geometry_atomic_counter_buffers_ext_value == 0) 2626 { 2627 throw tcu::NotSupportedError("GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT is 0"); 2628 } 2629 else 2630 { 2631 result = false; 2632 goto end; 2633 } 2634 } 2635 2636 /* Check if m_gl_max_atomic_counter_buffer_bindings_value is less than m_gl_max_shader_storage_blocks_value. */ 2637 if (m_gl_max_atomic_counter_buffer_bindings_value < m_gl_max_geometry_atomic_counter_buffers_ext_value) 2638 { 2639 m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT query value " 2640 << "[" << m_gl_max_geometry_atomic_counter_buffers_ext_value 2641 << "]" 2642 " is greater than GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS query value " 2643 "[" 2644 << m_gl_max_atomic_counter_buffer_bindings_value << "]." << tcu::TestLog::EndMessage; 2645 2646 result = false; 2647 goto end; 2648 } 2649 2650 /* Create a program object. */ 2651 m_po_id = gl.createProgram(); 2652 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 2653 2654 /* Create shader objects. */ 2655 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 2656 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 2657 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 2658 2659 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 2660 2661 /* Try to link the test program object */ 2662 fs_code_specialized = specializeShader(1, &dummy_fs_code); 2663 fs_code_specialized_raw = fs_code_specialized.c_str(); 2664 2665 gs_code_specialized = getGSCode(); 2666 gs_code_specialized_raw = gs_code_specialized.c_str(); 2667 2668 vs_code_specialized = specializeShader(1, &vs_code); 2669 vs_code_specialized_raw = vs_code_specialized.c_str(); 2670 2671 if (!TestCaseBase::buildProgram(m_po_id, m_gs_id, 1, /* n_sh1_body_parts */ 2672 &gs_code_specialized_raw, m_vs_id, 1, /* n_sh2_body_parts */ 2673 &vs_code_specialized_raw, m_fs_id, 1, /* n_sh3_body_parts */ 2674 &fs_code_specialized_raw, &has_shader_compilation_failed)) 2675 { 2676 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed." << tcu::TestLog::EndMessage; 2677 2678 result = false; 2679 goto end; 2680 } 2681 2682 /* Create Atomic Counter Buffer Objects. */ 2683 m_acbo_ids = new glw::GLuint[m_gl_max_geometry_atomic_counter_buffers_ext_value]; 2684 2685 gl.genBuffers(m_gl_max_geometry_atomic_counter_buffers_ext_value, m_acbo_ids); 2686 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 2687 2688 for (glw::GLint n_acb = 0; n_acb < m_gl_max_geometry_atomic_counter_buffers_ext_value; ++n_acb) 2689 { 2690 gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_acbo_ids[n_acb]); 2691 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed for GL_SHADER_STORAGE_BUFFER pname."); 2692 2693 gl.bufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(glw::GLuint), &initial_ac_data /*initialize with zeroes*/, 2694 GL_DYNAMIC_COPY); 2695 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 2696 2697 gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, n_acb /*binding index*/, m_acbo_ids[n_acb] /*buffer*/); 2698 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferRange() call failed."); 2699 } 2700 2701 /* Configure VAO. */ 2702 gl.genVertexArrays(1, &m_vao_id); 2703 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 2704 2705 gl.bindVertexArray(m_vao_id); 2706 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 2707 2708 /* Use program. */ 2709 gl.useProgram(m_po_id); 2710 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 2711 2712 gl.drawArrays(GL_POINTS, 0 /*starting index*/, number_of_indices); 2713 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed for GL_POINTS pname."); 2714 2715 /* Calculate expected value. */ 2716 /* For each point being processed by Geometry Shader. */ 2717 for (glw::GLuint vertex_id = 0; vertex_id < number_of_indices; ++vertex_id) 2718 { 2719 /* And for each atomic counter ID. */ 2720 for (int atomic_counter_id = 1; atomic_counter_id <= m_gl_max_geometry_atomic_counter_buffers_ext_value; 2721 ++atomic_counter_id) 2722 { 2723 /* Check if (vertex_id % atomic_counter_id) == 0. If it is true, increment expected_value. */ 2724 if (vertex_id % atomic_counter_id == 0) 2725 { 2726 ++expected_value; 2727 } 2728 } 2729 } 2730 2731 /* Retrieve values from Atomic Counter Buffer Objects and check if these values are valid. */ 2732 for (glw::GLint n_acb = 0; n_acb < m_gl_max_geometry_atomic_counter_buffers_ext_value; ++n_acb) 2733 { 2734 gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_acbo_ids[n_acb]); 2735 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); 2736 2737 glw::GLuint* ptrABO_data = (glw::GLuint*)gl.mapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0 /*offset*/, 2738 sizeof(glw::GLuint) /*length*/, GL_MAP_READ_BIT); 2739 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 2740 2741 if (ptrABO_data[0] != expected_value) 2742 { 2743 result = false; 2744 break; 2745 } 2746 2747 gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER); 2748 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 2749 2750 ptrABO_data = NULL; 2751 } 2752 2753 end: 2754 if (result) 2755 { 2756 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2757 } 2758 else 2759 { 2760 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2761 } 2762 2763 return STOP; 2764 } 2765 2766 /** Constructor 2767 * 2768 * @param context Test context 2769 * @param extParams Not used. 2770 * @param name Test case's name 2771 * @param description Test case's description 2772 **/ 2773 GeometryShaderPiplineProgramObjectWithoutActiveVSProgramTest:: 2774 GeometryShaderPiplineProgramObjectWithoutActiveVSProgramTest(Context& context, const ExtParameters& extParams, 2775 const char* name, const char* description) 2776 : TestCaseBase(context, extParams, name, description) 2777 , m_fs_id(0) 2778 , m_fs_po_id(0) 2779 , m_gs_id(0) 2780 , m_gs_po_id(0) 2781 , m_ppo_id(0) 2782 , m_vao_id(0) 2783 { 2784 } 2785 2786 /** Deinitializes GLES objects created during the test. */ 2787 void GeometryShaderPiplineProgramObjectWithoutActiveVSProgramTest::deinit() 2788 { 2789 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2790 2791 if (m_fs_id != 0) 2792 { 2793 gl.deleteShader(m_fs_id); 2794 m_fs_id = 0; 2795 } 2796 2797 if (m_fs_po_id != 0) 2798 { 2799 gl.deleteProgram(m_fs_po_id); 2800 m_fs_po_id = 0; 2801 } 2802 2803 if (m_gs_id != 0) 2804 { 2805 gl.deleteShader(m_gs_id); 2806 m_gs_id = 0; 2807 } 2808 2809 if (m_gs_po_id != 0) 2810 { 2811 gl.deleteProgram(m_gs_po_id); 2812 m_gs_po_id = 0; 2813 } 2814 2815 if (m_ppo_id != 0) 2816 { 2817 gl.deleteProgramPipelines(1, &m_ppo_id); 2818 m_ppo_id = 0; 2819 } 2820 2821 if (m_vao_id != 0) 2822 { 2823 gl.deleteVertexArrays(1, &m_vao_id); 2824 m_vao_id = 0; 2825 } 2826 2827 /* Release base class */ 2828 TestCaseBase::deinit(); 2829 } 2830 2831 /** Executes the test. 2832 * 2833 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 2834 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 2835 * Note the function throws exception should an error occur! 2836 **/ 2837 tcu::TestNode::IterateResult GeometryShaderPiplineProgramObjectWithoutActiveVSProgramTest::iterate() 2838 { 2839 bool has_shader_compilation_failed = true; 2840 bool result = true; 2841 glw::GLenum error = GL_NO_ERROR; 2842 2843 /* This test should only run if EXT_geometry_shader is supported. */ 2844 if (!m_is_geometry_shader_extension_supported) 2845 { 2846 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 2847 } 2848 2849 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2850 2851 /* Create separable program objects. */ 2852 m_fs_po_id = gl.createProgram(); 2853 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 2854 2855 gl.programParameteri(m_fs_po_id, GL_PROGRAM_SEPARABLE, GL_TRUE); 2856 GLU_EXPECT_NO_ERROR(gl.getError(), "glProgramParameteri() call failed."); 2857 2858 m_gs_po_id = gl.createProgram(); 2859 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 2860 2861 gl.programParameteri(m_gs_po_id, GL_PROGRAM_SEPARABLE, GL_TRUE); 2862 GLU_EXPECT_NO_ERROR(gl.getError(), "glProgramParameteri() call failed."); 2863 2864 /* Create shader objects. */ 2865 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 2866 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 2867 2868 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 2869 2870 /* Try to link the test program object */ 2871 std::string fs_code_specialized = specializeShader(1, &dummy_fs_code); 2872 const char* fs_code_specialized_raw = fs_code_specialized.c_str(); 2873 std::string gs_code_specialized = specializeShader(1, &dummy_gs_code); 2874 const char* gs_code_specialized_raw = gs_code_specialized.c_str(); 2875 2876 if (!TestCaseBase::buildProgram(m_fs_po_id, m_fs_id, 1, /* n_sh1_body_parts */ 2877 &fs_code_specialized_raw, 0, 0, /* n_sh2_body_parts */ 2878 NULL, 0, 0, /* n_sh3_body_parts */ 2879 NULL, &has_shader_compilation_failed)) 2880 { 2881 m_testCtx.getLog() << tcu::TestLog::Message << "Fragment Shader Program object linking failed." 2882 << tcu::TestLog::EndMessage; 2883 2884 result = false; 2885 goto end; 2886 } 2887 2888 if (!TestCaseBase::buildProgram(m_gs_po_id, m_gs_id, 1, /* n_sh1_body_parts */ 2889 &gs_code_specialized_raw, 0, 0, /* n_sh2_body_parts */ 2890 NULL, 0, 0, /* n_sh3_body_parts */ 2891 NULL, &has_shader_compilation_failed)) 2892 { 2893 m_testCtx.getLog() << tcu::TestLog::Message << "Geometry Shader Program object linking failed." 2894 << tcu::TestLog::EndMessage; 2895 2896 result = false; 2897 goto end; 2898 } 2899 2900 /* Configure Pipeline Object. */ 2901 gl.genProgramPipelines(1, &m_ppo_id); 2902 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); 2903 2904 gl.useProgramStages(m_ppo_id, GL_FRAGMENT_SHADER_BIT, m_fs_po_id); 2905 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 2906 2907 gl.useProgramStages(m_ppo_id, GL_GEOMETRY_SHADER_BIT, m_gs_po_id); 2908 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 2909 2910 /* Configure VAO. */ 2911 gl.genVertexArrays(1, &m_vao_id); 2912 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 2913 2914 gl.bindVertexArray(m_vao_id); 2915 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 2916 2917 /* Use Program Pipeline Object. */ 2918 gl.bindProgramPipeline(m_ppo_id); 2919 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 2920 2921 gl.drawArrays(GL_POINTS, 0 /*starting index*/, 1 /*number of indices*/); 2922 2923 error = gl.getError(); 2924 2925 /* Check if correct error was generated. */ 2926 if (GL_INVALID_OPERATION != error) 2927 { 2928 result = false; 2929 2930 m_testCtx.getLog() << tcu::TestLog::Message << "Error different than GL_INVALID_OPEARATION was generated." 2931 << tcu::TestLog::EndMessage; 2932 } 2933 2934 end: 2935 if (result) 2936 { 2937 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2938 } 2939 else 2940 { 2941 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2942 } 2943 2944 return STOP; 2945 } 2946 2947 /** Constructor 2948 * 2949 * @param context Test context 2950 * @param extParams Not used. 2951 * @param name Test case's name 2952 * @param description Test case's description 2953 **/ 2954 GeometryShaderIncompatibleDrawCallModeTest::GeometryShaderIncompatibleDrawCallModeTest(Context& context, 2955 const ExtParameters& extParams, 2956 const char* name, 2957 const char* description) 2958 : TestCaseBase(context, extParams, name, description) 2959 , m_fs_id(0) 2960 , m_gs_ids(NULL) 2961 , m_number_of_gs(5 /*taken from test spec*/) 2962 , m_po_ids(NULL) 2963 { 2964 m_vao_id = 0; 2965 m_vs_id = 0; 2966 } 2967 2968 /** Deinitializes GLES objects created during the test. */ 2969 void GeometryShaderIncompatibleDrawCallModeTest::deinit() 2970 { 2971 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2972 2973 if (m_fs_id != 0) 2974 { 2975 gl.deleteShader(m_fs_id); 2976 m_fs_id = 0; 2977 } 2978 2979 if (m_gs_ids != 0) 2980 { 2981 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 2982 { 2983 gl.deleteShader(m_gs_ids[i]); 2984 m_gs_ids[i] = 0; 2985 } 2986 2987 delete[] m_gs_ids; 2988 m_gs_ids = NULL; 2989 } 2990 2991 if (m_po_ids != 0) 2992 { 2993 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 2994 { 2995 gl.deleteProgram(m_po_ids[i]); 2996 m_po_ids[i] = 0; 2997 } 2998 2999 delete[] m_po_ids; 3000 m_po_ids = NULL; 3001 } 3002 3003 if (m_vao_id != 0) 3004 { 3005 gl.deleteVertexArrays(1, &m_vao_id); 3006 m_vao_id = 0; 3007 } 3008 3009 if (m_vs_id != 0) 3010 { 3011 gl.deleteShader(m_vs_id); 3012 m_vs_id = 0; 3013 } 3014 3015 /* Release base class */ 3016 TestCaseBase::deinit(); 3017 } 3018 3019 /** Executes the test. 3020 * 3021 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 3022 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 3023 * Note the function throws exception should an error occur! 3024 **/ 3025 tcu::TestNode::IterateResult GeometryShaderIncompatibleDrawCallModeTest::iterate() 3026 { 3027 /* Define 5 Geometry Shaders for purpose of this test. */ 3028 const char* gs_code_points = "${VERSION}\n" 3029 "${GEOMETRY_SHADER_REQUIRE}\n" 3030 "\n" 3031 "layout (points) in;\n" 3032 "layout (points, max_vertices = 1) out;\n" 3033 "\n" 3034 "${IN_PER_VERTEX_DECL_ARRAY}" 3035 "\n" 3036 "void main()\n" 3037 "{\n" 3038 " gl_Position = gl_in[0].gl_Position;\n" 3039 " EmitVertex();\n" 3040 "}\n"; 3041 3042 const char* gs_code_lines = "${VERSION}\n" 3043 "${GEOMETRY_SHADER_REQUIRE}\n" 3044 "\n" 3045 "layout (lines) in;\n" 3046 "layout (points, max_vertices = 1) out;\n" 3047 "\n" 3048 "${IN_PER_VERTEX_DECL_ARRAY}" 3049 "\n" 3050 "void main()\n" 3051 "{\n" 3052 " gl_Position = gl_in[0].gl_Position;\n" 3053 " EmitVertex();\n" 3054 "}\n"; 3055 3056 const char* gs_code_lines_adjacency = "${VERSION}\n" 3057 "${GEOMETRY_SHADER_REQUIRE}\n" 3058 "\n" 3059 "layout (lines_adjacency) in;\n" 3060 "layout (points, max_vertices = 1) out;\n" 3061 "\n" 3062 "${IN_PER_VERTEX_DECL_ARRAY}" 3063 "\n" 3064 "void main()\n" 3065 "{\n" 3066 " gl_Position = gl_in[0].gl_Position;\n" 3067 " EmitVertex();\n" 3068 "}\n"; 3069 3070 const char* gs_code_triangles = "${VERSION}\n" 3071 "${GEOMETRY_SHADER_REQUIRE}\n" 3072 "\n" 3073 "layout (triangles) in;\n" 3074 "layout (points, max_vertices = 1) out;\n" 3075 "\n" 3076 "${IN_PER_VERTEX_DECL_ARRAY}" 3077 "\n" 3078 "void main()\n" 3079 "{\n" 3080 " gl_Position = gl_in[0].gl_Position;\n" 3081 " EmitVertex();\n" 3082 "}\n"; 3083 3084 const char* gs_code_triangles_adjacency = "${VERSION}\n" 3085 "${GEOMETRY_SHADER_REQUIRE}\n" 3086 "\n" 3087 "layout (triangles_adjacency) in;\n" 3088 "layout (points, max_vertices = 1) out;\n" 3089 "\n" 3090 "${IN_PER_VERTEX_DECL_ARRAY}" 3091 "\n" 3092 "void main()\n" 3093 "{\n" 3094 " gl_Position = gl_in[0].gl_Position;\n" 3095 " EmitVertex();\n" 3096 "}\n"; 3097 3098 bool has_shader_compilation_failed = true; 3099 bool result = true; 3100 3101 m_gs_ids = new glw::GLuint[m_number_of_gs]; 3102 m_po_ids = new glw::GLuint[m_number_of_gs]; 3103 3104 /* This test should only run if EXT_geometry_shader is supported. */ 3105 if (!m_is_geometry_shader_extension_supported) 3106 { 3107 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 3108 } 3109 3110 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3111 3112 /* Create program objects & geometry shader objects. */ 3113 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 3114 { 3115 m_gs_ids[i] = gl.createShader(GL_GEOMETRY_SHADER); 3116 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 3117 3118 m_po_ids[i] = gl.createProgram(); 3119 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 3120 } 3121 3122 /* Create shader object. */ 3123 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 3124 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 3125 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 3126 3127 /* Try to link the test program object */ 3128 std::string fs_code_specialized = specializeShader(1, &dummy_fs_code); 3129 const char* fs_code_specialized_raw = fs_code_specialized.c_str(); 3130 3131 std::string gs_codes_specialized[] = { specializeShader(1, &gs_code_points), specializeShader(1, &gs_code_lines), 3132 specializeShader(1, &gs_code_lines_adjacency), 3133 specializeShader(1, &gs_code_triangles), 3134 specializeShader(1, &gs_code_triangles_adjacency) }; 3135 3136 const char* gs_codes_specialized_raw[] = { gs_codes_specialized[0].c_str(), gs_codes_specialized[1].c_str(), 3137 gs_codes_specialized[2].c_str(), gs_codes_specialized[3].c_str(), 3138 gs_codes_specialized[4].c_str() }; 3139 std::string vs_code_specialized = specializeShader(1, &dummy_vs_code); 3140 const char* vs_code_specialized_raw = vs_code_specialized.c_str(); 3141 3142 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 3143 { 3144 if (!TestCaseBase::buildProgram(m_po_ids[i], m_fs_id, 1, /* n_sh1_body_parts */ 3145 &fs_code_specialized_raw, m_gs_ids[i], 1, /* n_sh2_body_parts */ 3146 &gs_codes_specialized_raw[i], m_vs_id, 1, /* n_sh3_body_parts */ 3147 &vs_code_specialized_raw, &has_shader_compilation_failed)) 3148 { 3149 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed for i = " 3150 << "[" << i << "]." << tcu::TestLog::EndMessage; 3151 3152 result = false; 3153 break; 3154 } 3155 } 3156 3157 if (result) 3158 { 3159 /* Configure VAO. */ 3160 gl.genVertexArrays(1, &m_vao_id); 3161 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 3162 3163 gl.bindVertexArray(m_vao_id); 3164 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 3165 3166 for (glw::GLuint po = 0; po < m_number_of_gs; ++po) 3167 { 3168 /* Use Program Object. */ 3169 gl.useProgram(m_po_ids[po]); 3170 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 3171 3172 if (po != 0) 3173 { 3174 gl.drawArrays(GL_POINTS, 0 /*starting index*/, 1 /*number of indices*/); 3175 3176 if (GL_INVALID_OPERATION != gl.getError()) 3177 { 3178 result = false; 3179 3180 m_testCtx.getLog() << tcu::TestLog::Message 3181 << "Error different than GL_INVALID_OPEARATION was generated." 3182 << tcu::TestLog::EndMessage; 3183 3184 break; 3185 } 3186 } 3187 3188 if (po != 1) 3189 { 3190 gl.drawArrays(GL_LINES, 0 /*starting index*/, 2 /*number of indices*/); 3191 3192 if (GL_INVALID_OPERATION != gl.getError()) 3193 { 3194 result = false; 3195 3196 m_testCtx.getLog() << tcu::TestLog::Message 3197 << "Error different than GL_INVALID_OPEARATION was generated." 3198 << tcu::TestLog::EndMessage; 3199 3200 break; 3201 } 3202 3203 gl.drawArrays(GL_LINE_LOOP, 0 /*starting index*/, 2 /*number of indices*/); 3204 3205 if (GL_INVALID_OPERATION != gl.getError()) 3206 { 3207 result = false; 3208 3209 m_testCtx.getLog() << tcu::TestLog::Message 3210 << "Error different than GL_INVALID_OPEARATION was generated." 3211 << tcu::TestLog::EndMessage; 3212 3213 break; 3214 } 3215 3216 gl.drawArrays(GL_LINE_STRIP, 0 /*starting index*/, 2 /*number of indices*/); 3217 3218 if (GL_INVALID_OPERATION != gl.getError()) 3219 { 3220 result = false; 3221 3222 m_testCtx.getLog() << tcu::TestLog::Message 3223 << "Error different than GL_INVALID_OPEARATION was generated." 3224 << tcu::TestLog::EndMessage; 3225 3226 break; 3227 } 3228 } 3229 3230 if (po != 2) 3231 { 3232 gl.drawArrays(GL_LINES_ADJACENCY_EXT, 0 /*starting index*/, 4 /*number of indices*/); 3233 3234 if (GL_INVALID_OPERATION != gl.getError()) 3235 { 3236 result = false; 3237 3238 m_testCtx.getLog() << tcu::TestLog::Message 3239 << "Error different than GL_INVALID_OPEARATION was generated." 3240 << tcu::TestLog::EndMessage; 3241 3242 break; 3243 } 3244 3245 gl.drawArrays(GL_LINE_STRIP_ADJACENCY_EXT, 0 /*starting index*/, 4 /*number of indices*/); 3246 3247 if (GL_INVALID_OPERATION != gl.getError()) 3248 { 3249 result = false; 3250 3251 m_testCtx.getLog() << tcu::TestLog::Message 3252 << "Error different than GL_INVALID_OPEARATION was generated." 3253 << tcu::TestLog::EndMessage; 3254 3255 break; 3256 } 3257 } 3258 3259 if (po != 3) 3260 { 3261 gl.drawArrays(GL_TRIANGLES, 0 /*starting index*/, 3 /*number of indices*/); 3262 3263 if (GL_INVALID_OPERATION != gl.getError()) 3264 { 3265 result = false; 3266 3267 m_testCtx.getLog() << tcu::TestLog::Message 3268 << "Error different than GL_INVALID_OPEARATION was generated." 3269 << tcu::TestLog::EndMessage; 3270 3271 break; 3272 } 3273 3274 gl.drawArrays(GL_TRIANGLE_FAN, 0 /*starting index*/, 3 /*number of indices*/); 3275 3276 if (GL_INVALID_OPERATION != gl.getError()) 3277 { 3278 result = false; 3279 3280 m_testCtx.getLog() << tcu::TestLog::Message 3281 << "Error different than GL_INVALID_OPEARATION was generated." 3282 << tcu::TestLog::EndMessage; 3283 3284 break; 3285 } 3286 3287 gl.drawArrays(GL_TRIANGLE_STRIP, 0 /*starting index*/, 3 /*number of indices*/); 3288 3289 if (GL_INVALID_OPERATION != gl.getError()) 3290 { 3291 result = false; 3292 3293 m_testCtx.getLog() << tcu::TestLog::Message 3294 << "Error different than GL_INVALID_OPEARATION was generated." 3295 << tcu::TestLog::EndMessage; 3296 3297 break; 3298 } 3299 } 3300 3301 if (po != 4) 3302 { 3303 gl.drawArrays(GL_TRIANGLES_ADJACENCY_EXT, 0 /*starting index*/, 6 /*number of indices*/); 3304 3305 if (GL_INVALID_OPERATION != gl.getError()) 3306 { 3307 result = false; 3308 3309 m_testCtx.getLog() << tcu::TestLog::Message 3310 << "Error different than GL_INVALID_OPEARATION was generated." 3311 << tcu::TestLog::EndMessage; 3312 3313 break; 3314 } 3315 3316 gl.drawArrays(GL_TRIANGLE_STRIP_ADJACENCY_EXT, 0 /*starting index*/, 6 /*number of indices*/); 3317 3318 if (GL_INVALID_OPERATION != gl.getError()) 3319 { 3320 result = false; 3321 3322 m_testCtx.getLog() << tcu::TestLog::Message 3323 << "Error different than GL_INVALID_OPEARATION was generated." 3324 << tcu::TestLog::EndMessage; 3325 3326 break; 3327 } 3328 } 3329 } 3330 } 3331 3332 if (result) 3333 { 3334 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 3335 } 3336 else 3337 { 3338 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 3339 } 3340 3341 return STOP; 3342 } 3343 3344 /** Constructor 3345 * 3346 * @param context Test context 3347 * @param extParams Not used. 3348 * @param name Test case's name 3349 * @param description Test case's description 3350 **/ 3351 GeometryShaderInsufficientEmittedVerticesTest::GeometryShaderInsufficientEmittedVerticesTest( 3352 Context& context, const ExtParameters& extParams, const char* name, const char* description) 3353 : TestCaseBase(context, extParams, name, description) 3354 , m_fbo_id(0) 3355 , m_fs_id(0) 3356 , m_gs_ids(NULL) 3357 , m_number_of_color_components(4) 3358 , m_number_of_gs(2 /*taken from test spec*/) 3359 , m_po_ids(NULL) 3360 , m_texture_height(16) 3361 , m_texture_id(0) 3362 , m_texture_width(16) 3363 { 3364 m_vao_id = 0; 3365 m_vs_id = 0; 3366 3367 /* Allocate enough memory for glReadPixels() data which is respectively: width, height, RGBA components number. */ 3368 m_pixels = new glw::GLubyte[m_texture_height * m_texture_width * m_number_of_color_components]; 3369 } 3370 3371 /** Deinitializes GLES objects created during the test. */ 3372 void GeometryShaderInsufficientEmittedVerticesTest::deinit() 3373 { 3374 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3375 3376 gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 3377 3378 if (m_pixels != NULL) 3379 { 3380 delete[] m_pixels; 3381 m_pixels = NULL; 3382 } 3383 3384 if (m_fbo_id != 0) 3385 { 3386 gl.deleteFramebuffers(1, &m_fbo_id); 3387 m_fbo_id = 0; 3388 } 3389 3390 if (m_fs_id != 0) 3391 { 3392 gl.deleteShader(m_fs_id); 3393 m_fs_id = 0; 3394 } 3395 3396 if (m_gs_ids != 0) 3397 { 3398 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 3399 { 3400 gl.deleteShader(m_gs_ids[i]); 3401 m_gs_ids[i] = 0; 3402 } 3403 3404 delete[] m_gs_ids; 3405 m_gs_ids = NULL; 3406 } 3407 3408 if (m_po_ids != 0) 3409 { 3410 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 3411 { 3412 gl.deleteProgram(m_po_ids[i]); 3413 m_po_ids[i] = 0; 3414 } 3415 3416 delete[] m_po_ids; 3417 m_po_ids = NULL; 3418 } 3419 3420 if (m_texture_id != 0) 3421 { 3422 gl.deleteTextures(1, &m_texture_id); 3423 m_texture_id = 0; 3424 } 3425 3426 if (m_vao_id != 0) 3427 { 3428 gl.deleteVertexArrays(1, &m_vao_id); 3429 m_vao_id = 0; 3430 } 3431 3432 if (m_vs_id != 0) 3433 { 3434 gl.deleteShader(m_vs_id); 3435 m_vs_id = 0; 3436 } 3437 3438 /* Release base class */ 3439 TestCaseBase::deinit(); 3440 } 3441 3442 /** Executes the test. 3443 * 3444 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 3445 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 3446 * Note the function throws exception should an error occur! 3447 **/ 3448 tcu::TestNode::IterateResult GeometryShaderInsufficientEmittedVerticesTest::iterate() 3449 { 3450 /* Define Fragment Shader for purpose of this test. */ 3451 const char* fs_code = "${VERSION}\n" 3452 "\n" 3453 "precision highp float;\n" 3454 "\n" 3455 "out vec4 result;\n" 3456 "\n" 3457 "void main()\n" 3458 "{\n" 3459 " result = vec4(1.0, 0.0, 0.0, 0.0);\n" 3460 "}\n"; 3461 3462 /* Define 2 Geometry Shaders for purpose of this test. */ 3463 const char* gs_line_strip = "${VERSION}\n" 3464 "${GEOMETRY_SHADER_REQUIRE}\n" 3465 "\n" 3466 "layout (points) in;\n" 3467 "layout (line_strip, max_vertices = 2) out;\n" 3468 "\n" 3469 "${IN_PER_VERTEX_DECL_ARRAY}" 3470 "\n" 3471 "void main()\n" 3472 "{\n" 3473 " gl_Position = gl_in[0].gl_Position;\n" 3474 " gl_Position.zw = vec2(0.0, 1.0);\n" 3475 " EmitVertex();\n" 3476 "}\n"; 3477 3478 const char* gs_triangle_strip = "${VERSION}\n" 3479 "${GEOMETRY_SHADER_REQUIRE}\n" 3480 "\n" 3481 "layout (points) in;\n" 3482 "layout (triangle_strip, max_vertices = 3) out;\n" 3483 "\n" 3484 "${IN_PER_VERTEX_DECL_ARRAY}" 3485 "\n" 3486 "void main()\n" 3487 "{\n" 3488 " gl_Position = gl_in[0].gl_Position;\n" 3489 " gl_Position.zw = vec2(0.0, 1.0);\n" 3490 " EmitVertex();\n" 3491 3492 " gl_Position = gl_in[0].gl_Position;\n" 3493 " gl_Position.zw = vec2(0.0, 1.0);\n" 3494 " EmitVertex();\n" 3495 "}\n"; 3496 3497 bool has_shader_compilation_failed = true; 3498 bool result = true; 3499 3500 m_gs_ids = new glw::GLuint[m_number_of_gs]; 3501 m_po_ids = new glw::GLuint[m_number_of_gs]; 3502 3503 /* This test should only run if EXT_geometry_shader is supported. */ 3504 if (!m_is_geometry_shader_extension_supported) 3505 { 3506 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 3507 } 3508 3509 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3510 3511 /* Create program objects & geometry shader objects. */ 3512 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 3513 { 3514 m_gs_ids[i] = gl.createShader(GL_GEOMETRY_SHADER); 3515 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 3516 3517 m_po_ids[i] = gl.createProgram(); 3518 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 3519 } 3520 3521 /* Create shader object. */ 3522 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 3523 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 3524 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 3525 3526 /* Try to link the test program object */ 3527 std::string fs_code_specialized = specializeShader(1, &fs_code); 3528 const char* fs_code_specialized_raw = fs_code_specialized.c_str(); 3529 3530 std::string gs_codes_specialized[] = { specializeShader(1, &gs_line_strip), 3531 specializeShader(1, &gs_triangle_strip) }; 3532 3533 const char* gs_codes_specialized_raw[] = { gs_codes_specialized[0].c_str(), gs_codes_specialized[1].c_str() }; 3534 3535 std::string vs_code_specialized = specializeShader(1, &dummy_vs_code); 3536 const char* vs_code_specialized_raw = vs_code_specialized.c_str(); 3537 3538 for (glw::GLuint i = 0; i < m_number_of_gs; ++i) 3539 { 3540 if (!TestCaseBase::buildProgram(m_po_ids[i], m_fs_id, 1, /* n_sh1_body_parts */ 3541 &fs_code_specialized_raw, m_gs_ids[i], 1, /* n_sh2_body_parts */ 3542 &gs_codes_specialized_raw[i], m_vs_id, 1, /* n_sh3_body_parts */ 3543 &vs_code_specialized_raw, &has_shader_compilation_failed)) 3544 { 3545 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed for i = " 3546 << "[" << i << "]." << tcu::TestLog::EndMessage; 3547 3548 result = false; 3549 break; 3550 } 3551 } 3552 3553 if (result) 3554 { 3555 /* Create a 2D texture. */ 3556 gl.genTextures(1, &m_texture_id); 3557 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); 3558 3559 gl.bindTexture(GL_TEXTURE_2D, m_texture_id); 3560 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); 3561 3562 gl.texStorage2D(GL_TEXTURE_2D, 1 /*levels*/, GL_RGBA8, 16 /*width taken from spec*/, 3563 16 /*height taken from spec*/); 3564 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed."); 3565 3566 /* Configure FBO. */ 3567 gl.genFramebuffers(1, &m_fbo_id); 3568 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed."); 3569 3570 gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); 3571 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed."); 3572 3573 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture_id, 0 /*level*/); 3574 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed."); 3575 3576 /* Configure VAO. */ 3577 gl.genVertexArrays(1, &m_vao_id); 3578 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 3579 3580 gl.bindVertexArray(m_vao_id); 3581 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 3582 3583 gl.clearColor(0.0f, 1.0f, 0.0f, 0.0f); 3584 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor() call failed."); 3585 3586 for (glw::GLuint po = 0; po < m_number_of_gs; ++po) 3587 { 3588 /* Use Program Object. */ 3589 gl.useProgram(m_po_ids[po]); 3590 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 3591 3592 gl.clear(GL_COLOR_BUFFER_BIT); 3593 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed."); 3594 3595 gl.drawArrays(GL_POINTS, 0 /*first*/, 1 /*count*/); 3596 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed for GL_POINTS pname."); 3597 3598 gl.readPixels(0 /*x*/, 0 /*y*/, m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, m_pixels); 3599 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed."); 3600 3601 for (glw::GLuint pixel = 0; pixel < (m_texture_width * m_texture_height * m_number_of_color_components - 3602 m_number_of_color_components); 3603 pixel += m_number_of_color_components) 3604 { 3605 if (m_pixels[pixel] != 0 && m_pixels[pixel + 1] != 255 && m_pixels[pixel + 2] != 0 && 3606 m_pixels[pixel + 3] != 0) 3607 { 3608 result = false; 3609 3610 m_testCtx.getLog() << tcu::TestLog::Message << "Pixel [" << pixel << "] has color = [" 3611 << m_pixels[pixel] << ", " << m_pixels[pixel + 1] << ", " << m_pixels[pixel + 2] 3612 << ", " << m_pixels[pixel + 3] << "] " 3613 << "instead of [0, 255, 0, 0]." << tcu::TestLog::EndMessage; 3614 3615 break; 3616 } 3617 } 3618 } 3619 } 3620 3621 if (result) 3622 { 3623 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 3624 } 3625 else 3626 { 3627 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 3628 } 3629 3630 return STOP; 3631 } 3632 3633 /** Constructor 3634 * 3635 * @param context Test context 3636 * @param extParams Not used. 3637 * @param name Test case's name 3638 * @param description Test case's description 3639 **/ 3640 GeometryShaderPipelineObjectTransformFeedbackVertexAndGeometryShaderCaptureTest:: 3641 GeometryShaderPipelineObjectTransformFeedbackVertexAndGeometryShaderCaptureTest(Context& context, 3642 const ExtParameters& extParams, 3643 const char* name, 3644 const char* description) 3645 : TestCaseBase(context, extParams, name, description) 3646 , m_gs_id(0) 3647 , m_gs_po_id(0) 3648 , m_ppo_id(0) 3649 , m_tfbo_id(0) 3650 , m_vao_id(0) 3651 , m_vs_id(0) 3652 , m_vs_po_id(0) 3653 { 3654 } 3655 3656 /** Deinitializes GLES objects created during the test. */ 3657 void GeometryShaderPipelineObjectTransformFeedbackVertexAndGeometryShaderCaptureTest::deinit() 3658 { 3659 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3660 3661 if (m_gs_id != 0) 3662 { 3663 gl.deleteShader(m_gs_id); 3664 m_gs_id = 0; 3665 } 3666 3667 if (m_gs_po_id != 0) 3668 { 3669 gl.deleteProgram(m_gs_po_id); 3670 m_gs_po_id = 0; 3671 } 3672 3673 if (m_ppo_id != 0) 3674 { 3675 gl.deleteProgramPipelines(1, &m_ppo_id); 3676 m_ppo_id = 0; 3677 } 3678 3679 if (m_tfbo_id != 0) 3680 { 3681 gl.deleteBuffers(1, &m_tfbo_id); 3682 m_tfbo_id = 0; 3683 } 3684 3685 if (m_vao_id != 0) 3686 { 3687 gl.deleteVertexArrays(1, &m_vao_id); 3688 m_vao_id = 0; 3689 } 3690 3691 if (m_vs_id != 0) 3692 { 3693 gl.deleteShader(m_vs_id); 3694 m_vs_id = 0; 3695 } 3696 3697 if (m_vs_po_id != 0) 3698 { 3699 gl.deleteProgram(m_vs_po_id); 3700 m_vs_po_id = 0; 3701 } 3702 3703 /* Release base class */ 3704 TestCaseBase::deinit(); 3705 } 3706 3707 /** Executes the test. 3708 * 3709 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 3710 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 3711 * Note the function throws exception should an error occur! 3712 **/ 3713 tcu::TestNode::IterateResult GeometryShaderPipelineObjectTransformFeedbackVertexAndGeometryShaderCaptureTest::iterate() 3714 { 3715 /* Define Geometry Shader for purpose of this test. */ 3716 const char* gs_code = 3717 "${VERSION}\n" 3718 "${GEOMETRY_SHADER_REQUIRE}\n" 3719 "${IN_PER_VERTEX_DECL_ARRAY}\n" 3720 "${OUT_PER_VERTEX_DECL}\n" 3721 "\n" 3722 "layout (points) in;\n" 3723 "layout (points, max_vertices = 1) out;\n" 3724 "\n" 3725 "flat in int vertexID[];\n" 3726 "flat in ivec4 out_vs_1[];\n" 3727 "\n" 3728 "out vec4 out_gs_1;\n" 3729 "\n" 3730 "void main()\n" 3731 "{\n" 3732 " out_gs_1 = vec4(vertexID[0] * 2, vertexID[0] * 2 + 1, vertexID[0] * 2 + 2, vertexID[0] * 2 + 3);\n" 3733 " gl_Position = vec4(0, 0, 0, 1);\n" 3734 " EmitVertex();\n" 3735 "}\n"; 3736 3737 /* Define Vertex Shader for purpose of this test. */ 3738 const char* vs_code = "${VERSION}\n" 3739 "${OUT_PER_VERTEX_DECL}\n" 3740 "\n" 3741 "flat out ivec4 out_vs_1;\n" 3742 "flat out int vertexID;\n" 3743 "\n" 3744 "void main()\n" 3745 "{\n" 3746 " vertexID = gl_VertexID;\n" 3747 " out_vs_1 = ivec4(gl_VertexID, gl_VertexID + 1, gl_VertexID + 2, gl_VertexID + 3);\n" 3748 " gl_Position = vec4(1.0, 0.0, 0.0, 1.0);\n" 3749 "}\n"; 3750 3751 bool has_shader_compilation_failed = true; 3752 bool result = true; 3753 glw::GLfloat* ptrTF_data_f = NULL; 3754 glw::GLuint* ptrTF_data_ui = NULL; 3755 glw::GLfloat expected_geom_results[] = { 0.0f, 1.0f, 2.0f, 3.0f }; 3756 glw::GLuint expected_vertex_results[] = { 0, 1, 2, 3 }; 3757 glw::GLfloat epsilon = 1e-5f; 3758 3759 /* This test should only run if EXT_geometry_shader is supported. */ 3760 if (!m_is_geometry_shader_extension_supported) 3761 { 3762 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 3763 } 3764 3765 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3766 3767 /* Create separable program objects. */ 3768 m_gs_po_id = gl.createProgram(); 3769 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 3770 3771 gl.programParameteri(m_gs_po_id, GL_PROGRAM_SEPARABLE, GL_TRUE); 3772 GLU_EXPECT_NO_ERROR(gl.getError(), "glProgramParameteri() call failed."); 3773 3774 m_vs_po_id = gl.createProgram(); 3775 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 3776 3777 gl.programParameteri(m_vs_po_id, GL_PROGRAM_SEPARABLE, GL_TRUE); 3778 GLU_EXPECT_NO_ERROR(gl.getError(), "glProgramParameteri() call failed."); 3779 3780 /* Create shader objects. */ 3781 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 3782 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 3783 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 3784 3785 /* Try to link the test program object */ 3786 std::string gs_code_specialized = specializeShader(1, &gs_code); 3787 const char* gs_code_specialized_raw = gs_code_specialized.c_str(); 3788 3789 std::string vs_code_specialized = specializeShader(1, &vs_code); 3790 const char* vs_code_specialized_raw = vs_code_specialized.c_str(); 3791 3792 /* Specify output variables to be captured. */ 3793 const char* tf_varyings[2] = { "out_gs_1", "out_vs_1" }; 3794 3795 gl.transformFeedbackVaryings(m_gs_po_id, 1 /*count*/, &tf_varyings[0], GL_INTERLEAVED_ATTRIBS); 3796 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call(s) failed."); 3797 3798 gl.transformFeedbackVaryings(m_vs_po_id, 1 /*count*/, &tf_varyings[1], GL_INTERLEAVED_ATTRIBS); 3799 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call(s) failed."); 3800 3801 if (!TestCaseBase::buildProgram(m_gs_po_id, m_gs_id, 1, /* n_sh1_body_parts */ 3802 &gs_code_specialized_raw, 0, 0, /* n_sh2_body_parts */ 3803 NULL, 0, 0, /* n_sh3_body_parts */ 3804 NULL, &has_shader_compilation_failed)) 3805 { 3806 m_testCtx.getLog() << tcu::TestLog::Message << "Geometry Shader Program object linking failed." 3807 << tcu::TestLog::EndMessage; 3808 3809 result = false; 3810 goto end; 3811 } 3812 3813 if (!TestCaseBase::buildProgram(m_vs_po_id, m_vs_id, 1, /* n_sh1_body_parts */ 3814 &vs_code_specialized_raw, 0, 0, /* n_sh2_body_parts */ 3815 NULL, 0, 0, /* n_sh3_body_parts */ 3816 NULL, &has_shader_compilation_failed)) 3817 { 3818 m_testCtx.getLog() << tcu::TestLog::Message << "Geometry Shader Program object linking failed." 3819 << tcu::TestLog::EndMessage; 3820 3821 result = false; 3822 goto end; 3823 } 3824 3825 /* Create and configure Program Pipeline Object. */ 3826 gl.genProgramPipelines(1, &m_ppo_id); 3827 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call(s) failed."); 3828 3829 gl.useProgramStages(m_ppo_id, GL_GEOMETRY_SHADER_BIT, m_gs_po_id); 3830 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call(s) failed."); 3831 3832 gl.useProgramStages(m_ppo_id, GL_VERTEX_SHADER_BIT, m_vs_po_id); 3833 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call(s) failed."); 3834 3835 /* Create Vertex Array Object. */ 3836 gl.genVertexArrays(1, &m_vao_id); 3837 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call(s) failed."); 3838 3839 gl.bindVertexArray(m_vao_id); 3840 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call(s) failed."); 3841 3842 /* Create Buffer Object for Transform Feedback data. */ 3843 gl.genBuffers(1, &m_tfbo_id); 3844 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call(s) failed."); 3845 3846 gl.bindBuffer(GL_ARRAY_BUFFER, m_tfbo_id); 3847 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call(s) failed."); 3848 3849 gl.bufferData(GL_ARRAY_BUFFER, sizeof(glw::GLfloat) * 4, NULL, GL_STREAM_READ); 3850 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call(s) failed."); 3851 3852 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /*binding index*/, m_tfbo_id); 3853 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call(s) failed."); 3854 3855 /* Ensure that there is no program object already bound and bind program pipeline. */ 3856 gl.useProgram(0); 3857 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call(s) failed."); 3858 3859 gl.bindProgramPipeline(m_ppo_id); 3860 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call(s) failed."); 3861 3862 gl.enable(GL_RASTERIZER_DISCARD); 3863 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable() call(s) failed."); 3864 3865 /* First pass - Vertex and Geometry Shaders On. */ 3866 gl.beginTransformFeedback(GL_POINTS); 3867 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call(s) failed."); 3868 3869 gl.drawArrays(GL_POINTS, 0 /*first*/, 1 /*count*/); 3870 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call(s) failed."); 3871 3872 gl.endTransformFeedback(); 3873 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call(s) failed."); 3874 3875 /* Retrieve data and check if it is correct. */ 3876 ptrTF_data_f = 3877 (glw::GLfloat*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /*offset*/, 3878 sizeof(glw::GLfloat) * 4 /* four float vector components */, GL_MAP_READ_BIT); 3879 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 3880 3881 for (size_t i = 0; i < 4; ++i) 3882 { 3883 if (fabs(ptrTF_data_f[i] - expected_geom_results[i]) >= epsilon) 3884 { 3885 result = false; 3886 break; 3887 } 3888 } 3889 3890 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 3891 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 3892 3893 ptrTF_data_f = NULL; 3894 3895 if (!result) 3896 { 3897 goto end; 3898 } 3899 3900 /* Deactivate Geometry Shader Program Object from Program Pipeline Object. */ 3901 gl.useProgramStages(m_ppo_id, GL_GEOMETRY_SHADER_BIT, 0 /* program */); 3902 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call(s) failed."); 3903 3904 /* Second pass - only Vertex Shader Program On. */ 3905 gl.beginTransformFeedback(GL_POINTS); 3906 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call(s) failed."); 3907 3908 gl.drawArrays(GL_POINTS, 0 /*first*/, 1 /*count*/); 3909 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call(s) failed."); 3910 3911 gl.endTransformFeedback(); 3912 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call(s) failed."); 3913 3914 gl.disable(GL_RASTERIZER_DISCARD); 3915 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable() call(s) failed."); 3916 3917 /* Retrieve data and check if it is correct. */ 3918 ptrTF_data_ui = 3919 (glw::GLuint*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /*offset*/, 3920 sizeof(glw::GLuint) * 4 /* four float vector components */, GL_MAP_READ_BIT); 3921 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed."); 3922 3923 for (size_t i = 0; i < 4; ++i) 3924 { 3925 if (ptrTF_data_ui[i] != expected_vertex_results[i]) 3926 { 3927 result = false; 3928 break; 3929 } 3930 } 3931 3932 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 3933 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 3934 3935 ptrTF_data_ui = NULL; 3936 3937 end: 3938 if (result) 3939 { 3940 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 3941 } 3942 else 3943 { 3944 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 3945 } 3946 3947 return STOP; 3948 } 3949 3950 /** Constructor 3951 * 3952 * @param context Test context 3953 * @param extParams Not used. 3954 * @param name Test case's name 3955 * @param description Test case's description 3956 **/ 3957 GeometryShaderDrawPrimitivesDoNotMatchOutputPrimitives::GeometryShaderDrawPrimitivesDoNotMatchOutputPrimitives( 3958 Context& context, const ExtParameters& extParams, const char* name, const char* description) 3959 : TestCaseBase(context, extParams, name, description), m_fs_id(0), m_gs_id(0), m_po_id(0), m_tfbo_id(0) 3960 { 3961 m_vao_id = 0; 3962 m_vs_id = 0; 3963 } 3964 3965 /** Deinitializes GLES objects created during the test. */ 3966 void GeometryShaderDrawPrimitivesDoNotMatchOutputPrimitives::deinit() 3967 { 3968 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3969 3970 if (m_fs_id != 0) 3971 { 3972 gl.deleteShader(m_fs_id); 3973 m_fs_id = 0; 3974 } 3975 3976 if (m_gs_id != 0) 3977 { 3978 gl.deleteShader(m_gs_id); 3979 m_gs_id = 0; 3980 } 3981 3982 if (m_po_id != 0) 3983 { 3984 gl.deleteProgram(m_po_id); 3985 m_po_id = 0; 3986 } 3987 3988 if (m_tfbo_id != 0) 3989 { 3990 gl.deleteBuffers(1, &m_tfbo_id); 3991 m_tfbo_id = 0; 3992 } 3993 3994 if (m_vao_id != 0) 3995 { 3996 gl.deleteVertexArrays(1, &m_vao_id); 3997 m_vao_id = 0; 3998 } 3999 4000 if (m_vs_id != 0) 4001 { 4002 gl.deleteShader(m_vs_id); 4003 m_vs_id = 0; 4004 } 4005 4006 /* Release base class */ 4007 TestCaseBase::deinit(); 4008 } 4009 4010 /** Executes the test. 4011 * 4012 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 4013 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 4014 * Note the function throws exception should an error occur! 4015 **/ 4016 tcu::TestNode::IterateResult GeometryShaderDrawPrimitivesDoNotMatchOutputPrimitives::iterate() 4017 { 4018 /* Define Geometry Shader for purpose of this test. */ 4019 const char* gs_code = "${VERSION}\n" 4020 "${GEOMETRY_SHADER_REQUIRE}\n" 4021 "\n" 4022 "layout (lines) in;\n" 4023 "layout (triangle_strip, max_vertices = 3) out;\n" 4024 "\n" 4025 "out vec4 out_gs_1;\n" 4026 "\n" 4027 "void main()\n" 4028 "{\n" 4029 " out_gs_1 = vec4(4.0, 3.0, 2.0, 1.0);\n" 4030 "\n" 4031 " gl_Position = vec4(0, 0, 0, 1);\n" 4032 " EmitVertex();\n" 4033 "\n" 4034 " gl_Position = vec4(1, 0, 0, 1);\n" 4035 " EmitVertex();\n" 4036 "\n" 4037 " gl_Position = vec4(1, 1, 0, 1);\n" 4038 " EmitVertex();\n" 4039 "\n" 4040 " EndPrimitive();" 4041 "}\n"; 4042 4043 bool has_shader_compilation_failed = true; 4044 bool result = true; 4045 glw::GLenum error = GL_NO_ERROR; 4046 4047 /* This test should only run if EXT_geometry_shader is supported. */ 4048 if (!m_is_geometry_shader_extension_supported) 4049 { 4050 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 4051 } 4052 4053 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4054 4055 /* Create program object. */ 4056 m_po_id = gl.createProgram(); 4057 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 4058 4059 /* Specify output variables to be captured. */ 4060 const char* tf_varyings[] = { "out_gs_1" }; 4061 4062 gl.transformFeedbackVaryings(m_po_id, 1 /*count*/, tf_varyings, GL_INTERLEAVED_ATTRIBS); 4063 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call(s) failed."); 4064 4065 /* Create shader objects. */ 4066 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 4067 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 4068 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 4069 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 4070 4071 /* Try to link the test program object */ 4072 std::string fs_code_specialized = specializeShader(1, &dummy_fs_code); 4073 const char* fs_code_specialized_raw = fs_code_specialized.c_str(); 4074 4075 std::string gs_code_specialized = specializeShader(1, &gs_code); 4076 const char* gs_code_specialized_raw = gs_code_specialized.c_str(); 4077 4078 std::string vs_code_specialized = specializeShader(1, &dummy_vs_code); 4079 const char* vs_code_specialized_raw = vs_code_specialized.c_str(); 4080 4081 if (!TestCaseBase::buildProgram(m_po_id, m_fs_id, 1, /* n_sh1_body_parts */ 4082 &fs_code_specialized_raw, m_gs_id, 1, /* n_sh2_body_parts */ 4083 &gs_code_specialized_raw, m_vs_id, 1, /* n_sh3_body_parts */ 4084 &vs_code_specialized_raw, &has_shader_compilation_failed)) 4085 { 4086 m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed whereas a success was expected." 4087 << tcu::TestLog::EndMessage; 4088 4089 result = false; 4090 goto end; 4091 } 4092 4093 /* Create Vertex Array Object. */ 4094 gl.genVertexArrays(1, &m_vao_id); 4095 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call(s) failed."); 4096 4097 gl.bindVertexArray(m_vao_id); 4098 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call(s) failed."); 4099 4100 /* Create Buffer Object for Transform Feedback data. */ 4101 gl.genBuffers(1, &m_tfbo_id); 4102 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call(s) failed."); 4103 4104 gl.bindBuffer(GL_ARRAY_BUFFER, m_tfbo_id); 4105 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call(s) failed."); 4106 4107 gl.bufferData(GL_ARRAY_BUFFER, 4108 sizeof(glw::GLfloat) * 4 * 3 /* capture 4 float vector components times 3 triangle vertices */, NULL, 4109 GL_STREAM_READ); 4110 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call(s) failed."); 4111 4112 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /*binding index*/, m_tfbo_id); 4113 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call(s) failed."); 4114 4115 /* Turn on program object. */ 4116 gl.useProgram(m_po_id); 4117 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call(s) failed."); 4118 4119 gl.enable(GL_RASTERIZER_DISCARD); 4120 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable() call(s) failed."); 4121 4122 gl.beginTransformFeedback(GL_LINES); 4123 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call(s) failed."); 4124 4125 gl.drawArrays(GL_TRIANGLES, 0 /*first*/, 3 /*count*/); 4126 4127 error = gl.getError(); 4128 4129 if (error != GL_INVALID_OPERATION) 4130 { 4131 result = false; 4132 4133 m_testCtx.getLog() << tcu::TestLog::Message << "Error different than GL_INVALID_OPEARATION was generated." 4134 << tcu::TestLog::EndMessage; 4135 } 4136 4137 gl.endTransformFeedback(); 4138 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call(s) failed."); 4139 4140 gl.disable(GL_RASTERIZER_DISCARD); 4141 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable() call(s) failed."); 4142 4143 end: 4144 4145 if (result) 4146 { 4147 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 4148 } 4149 else 4150 { 4151 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 4152 } 4153 4154 return STOP; 4155 } 4156 4157 /** Constructor 4158 * 4159 * @param context Test context 4160 * @param extParams Not used. 4161 * @param name Test case's name 4162 * @param description Test case's description 4163 **/ 4164 GeometryShaderDrawCallsWhileTFPaused::GeometryShaderDrawCallsWhileTFPaused(Context& context, 4165 const ExtParameters& extParams, 4166 const char* name, const char* description) 4167 : TestCaseBase(context, extParams, name, description), m_fs_id(0), m_gs_id(0), m_tfbo_id(0) 4168 { 4169 m_vao_id = 0; 4170 m_vs_id = 0; 4171 } 4172 4173 /** Deinitializes GLES objects created during the test. */ 4174 void GeometryShaderDrawCallsWhileTFPaused::deinit() 4175 { 4176 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4177 4178 if (m_fs_id != 0) 4179 { 4180 gl.deleteShader(m_fs_id); 4181 m_fs_id = 0; 4182 } 4183 4184 if (m_gs_id != 0) 4185 { 4186 gl.deleteShader(m_gs_id); 4187 m_gs_id = 0; 4188 } 4189 4190 for (int i = 0; i < 15 /* All combinations of possible inputs and outputs in GS */; ++i) 4191 { 4192 if (m_po_ids[i] != 0) 4193 { 4194 gl.deleteProgram(m_po_ids[i]); 4195 m_po_ids[i] = 0; 4196 } 4197 } 4198 4199 if (m_tfbo_id != 0) 4200 { 4201 gl.deleteBuffers(1, &m_tfbo_id); 4202 m_tfbo_id = 0; 4203 } 4204 4205 if (m_vao_id != 0) 4206 { 4207 gl.deleteVertexArrays(1, &m_vao_id); 4208 m_vao_id = 0; 4209 } 4210 4211 if (m_vs_id != 0) 4212 { 4213 gl.deleteShader(m_vs_id); 4214 m_vs_id = 0; 4215 } 4216 4217 /* Release base class */ 4218 TestCaseBase::deinit(); 4219 } 4220 4221 /** Executes the test. 4222 * 4223 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. 4224 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. 4225 * Note the function throws exception should an error occur! 4226 **/ 4227 tcu::TestNode::IterateResult GeometryShaderDrawCallsWhileTFPaused::iterate() 4228 { 4229 /* Define 15 (all combinations of possible inputs and outputs in geometry shader) Geometry Shaders for purpose of this test. */ 4230 const std::string gs_inputs[] = { "points", "lines", "lines_adjacency", "triangles", "triangles_adjacency" }; 4231 const std::string gs_outputs[] = { "points", "line_strip", "triangle_strip" }; 4232 const std::string gs_max_output_vertices[] = { "1", "2", "3" }; 4233 4234 const unsigned short number_of_combinations = 4235 (sizeof(gs_inputs) / sizeof(gs_inputs[0]) * (sizeof(gs_outputs) / sizeof(gs_outputs[0]))); 4236 4237 std::string gs_codes[number_of_combinations]; 4238 glw::GLenum errorCode; 4239 4240 for (size_t i = 0; i < (sizeof(gs_inputs) / sizeof(gs_inputs[0])) /*5 possible GS inputs*/; ++i) 4241 { 4242 for (size_t j = 0; j < (sizeof(gs_outputs) / sizeof(gs_outputs[0])) /*3 possible GS outputs*/; ++j) 4243 { 4244 /* This shader will not emit primitives for anything but points. 4245 * We do so, because we just need to make sure that, while transform feedback 4246 * is paused, all draw calls executed with an active program object which 4247 * includes a geometry shader, are valid. 4248 */ 4249 gs_codes[j + 3 * i] = "${VERSION}\n" 4250 "${GEOMETRY_SHADER_REQUIRE}\n" 4251 "\n" 4252 "layout (" + 4253 gs_inputs[i] + ") in;\n" 4254 "layout (" + 4255 gs_outputs[j] + ", max_vertices = " + gs_max_output_vertices[j] + 4256 ") out;\n" 4257 "\n" 4258 "out vec2 out_gs_1;\n" 4259 "\n" 4260 "void main()\n" 4261 "{\n" 4262 " out_gs_1 = vec2(1.0, 2.0);\n" 4263 " gl_Position = vec4(0, 0, 0, 1);\n" 4264 " EmitVertex();\n" 4265 "}\n"; 4266 } 4267 } 4268 4269 bool has_shader_compilation_failed = true; 4270 bool result = true; 4271 const glw::GLuint tf_modes[3] = { GL_POINTS, GL_LINES, GL_TRIANGLES }; 4272 const glw::GLuint draw_call_modes[5] = { GL_POINTS, GL_LINES, GL_LINES_ADJACENCY, GL_TRIANGLES, 4273 GL_TRIANGLES_ADJACENCY }; 4274 4275 /* This test should only run if EXT_geometry_shader is supported. */ 4276 if (!m_is_geometry_shader_extension_supported) 4277 { 4278 throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); 4279 } 4280 4281 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4282 4283 /* Create program objects. */ 4284 for (int i = 0; i < number_of_combinations; ++i) 4285 { 4286 m_po_ids[i] = gl.createProgram(); 4287 } 4288 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call(s) failed."); 4289 4290 /* Specify output variables to be captured. */ 4291 const char* tf_varyings[] = { "out_gs_1" }; 4292 4293 for (int i = 0; i < number_of_combinations; ++i) 4294 { 4295 gl.transformFeedbackVaryings(m_po_ids[i], 1 /*count*/, tf_varyings, GL_INTERLEAVED_ATTRIBS); 4296 } 4297 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call(s) failed."); 4298 4299 /* Create shader objects. */ 4300 m_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 4301 m_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 4302 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 4303 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed."); 4304 4305 /* Try to link the test program object */ 4306 std::string fs_code_specialized = specializeShader(1, &dummy_fs_code); 4307 const char* fs_code_specialized_raw = fs_code_specialized.c_str(); 4308 4309 std::string vs_code_specialized = specializeShader(1, &dummy_vs_code); 4310 const char* vs_code_specialized_raw = vs_code_specialized.c_str(); 4311 4312 for (int i = 0; i < number_of_combinations; ++i) 4313 { 4314 const char* gs_code = gs_codes[i].c_str(); 4315 std::string gs_code_specialized = specializeShader(1, &gs_code); 4316 const char* gs_code_specialized_raw = gs_code_specialized.c_str(); 4317 4318 if (!TestCaseBase::buildProgram(m_po_ids[i], m_fs_id, 1, /* n_sh1_body_parts */ 4319 &fs_code_specialized_raw, m_gs_id, 1, /* n_sh2_body_parts */ 4320 &gs_code_specialized_raw, m_vs_id, 1, /* n_sh3_body_parts */ 4321 &vs_code_specialized_raw, &has_shader_compilation_failed)) 4322 { 4323 m_testCtx.getLog() << tcu::TestLog::Message 4324 << "Program object linking failed whereas a success was expected." 4325 << tcu::TestLog::EndMessage; 4326 4327 result = false; 4328 } 4329 } 4330 4331 if (!result) 4332 { 4333 goto end; 4334 } 4335 4336 /* Create Vertex Array Object. */ 4337 gl.genVertexArrays(1, &m_vao_id); 4338 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call(s) failed."); 4339 4340 gl.bindVertexArray(m_vao_id); 4341 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call(s) failed."); 4342 4343 /* Create Buffer Object for Transform Feedback data. */ 4344 gl.genBuffers(1, &m_tfbo_id); 4345 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call(s) failed."); 4346 4347 gl.bindBuffer(GL_ARRAY_BUFFER, m_tfbo_id); 4348 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call(s) failed."); 4349 4350 gl.bufferData(GL_ARRAY_BUFFER, 4351 sizeof(glw::GLfloat) * 2 * 3 /* capture 2 float vector components times 3 triangle vertices */, NULL, 4352 GL_STREAM_READ); 4353 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call(s) failed."); 4354 4355 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /*binding index*/, m_tfbo_id); 4356 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call(s) failed."); 4357 4358 gl.enable(GL_RASTERIZER_DISCARD); 4359 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable() call(s) failed."); 4360 4361 for (int i = 0; i < 3 /* number of TF modes */ && result; ++i) 4362 { 4363 for (int j = 0; j < 5 /*number of draw call modes*/ && result; ++j) 4364 { 4365 for (int k = 0; k < 3 /* number of output GS primitive types */; ++k) 4366 { 4367 /* Turn on program object. */ 4368 gl.useProgram(m_po_ids[k + 3 * j]); 4369 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call(s) failed."); 4370 4371 gl.beginTransformFeedback(tf_modes[i]); 4372 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call(s) failed."); 4373 4374 gl.pauseTransformFeedback(); 4375 GLU_EXPECT_NO_ERROR(gl.getError(), "glPauseTransformFeedback() call(s) failed."); 4376 4377 gl.drawArrays(draw_call_modes[j], 0 /*first*/, 3 /*count*/); 4378 errorCode = gl.getError(); 4379 4380 gl.resumeTransformFeedback(); 4381 GLU_EXPECT_NO_ERROR(gl.getError(), "glResumeTransformFeedback() call(s) failed."); 4382 4383 gl.endTransformFeedback(); 4384 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call(s) failed."); 4385 4386 /* If draw call fails stop test execution. */ 4387 if (GL_NO_ERROR != errorCode) 4388 { 4389 m_testCtx.getLog() << tcu::TestLog::Message 4390 << "glDrawArrays() call generated an error while transform feedback was paused." 4391 << tcu::TestLog::EndMessage; 4392 4393 result = false; 4394 break; 4395 } 4396 } 4397 } 4398 } 4399 4400 gl.disable(GL_RASTERIZER_DISCARD); 4401 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable() call(s) failed."); 4402 4403 end: 4404 4405 if (result) 4406 { 4407 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 4408 } 4409 else 4410 { 4411 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 4412 } 4413 4414 return STOP; 4415 } 4416 4417 } // namespace glcts 4418
