1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2014-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 24 /** 25 * \file gl4cShaderSubroutineTests.cpp 26 * \brief Implements conformance tests for "Shader Subroutine" functionality. 27 */ /*-------------------------------------------------------------------*/ 28 29 #include "gl4cShaderSubroutineTests.hpp" 30 #include "gluContextInfo.hpp" 31 #include "glwEnums.hpp" 32 #include "glwFunctions.hpp" 33 #include "tcuMatrix.hpp" 34 #include <cmath> 35 #include <cstring> 36 #include <deMath.h> 37 38 using namespace glw; 39 40 namespace gl4cts 41 { 42 namespace ShaderSubroutine 43 { 44 /** Constructor. 45 * 46 * @param context CTS context. 47 **/ 48 Utils::buffer::buffer(deqp::Context& context) : m_id(0), m_context(context) 49 { 50 } 51 52 /** Destructor 53 * 54 **/ 55 Utils::buffer::~buffer() 56 { 57 if (0 != m_id) 58 { 59 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 60 61 gl.deleteBuffers(1, &m_id); 62 m_id = 0; 63 } 64 } 65 66 /** Execute BindBufferRange 67 * 68 * @param target <target> parameter 69 * @param index <index> parameter 70 * @param offset <offset> parameter 71 * @param size <size> parameter 72 **/ 73 void Utils::buffer::bindRange(glw::GLenum target, glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size) 74 { 75 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 76 77 gl.bindBufferRange(target, index, m_id, offset, size); 78 GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferRange"); 79 } 80 81 /** Execute GenBuffer 82 * 83 **/ 84 void Utils::buffer::generate() 85 { 86 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 87 88 gl.genBuffers(1, &m_id); 89 GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers"); 90 } 91 92 /** Execute BufferData 93 * 94 * @param target <target> parameter 95 * @param size <size> parameter 96 * @param data <data> parameter 97 * @param usage <usage> parameter 98 **/ 99 void Utils::buffer::update(glw::GLenum target, glw::GLsizeiptr size, glw::GLvoid* data, glw::GLenum usage) 100 { 101 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 102 103 gl.bindBuffer(target, m_id); 104 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer"); 105 106 gl.bufferData(target, size, data, usage); 107 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData"); 108 } 109 110 /** Constructor 111 * 112 * @param context CTS context 113 **/ 114 Utils::framebuffer::framebuffer(deqp::Context& context) : m_id(0), m_context(context) 115 { 116 /* Nothing to be done here */ 117 } 118 119 /** Destructor 120 * 121 **/ 122 Utils::framebuffer::~framebuffer() 123 { 124 if (0 != m_id) 125 { 126 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 127 128 gl.deleteFramebuffers(1, &m_id); 129 m_id = 0; 130 } 131 } 132 133 /** Attach texture to specified attachment 134 * 135 * @param attachment Attachment 136 * @param texture_id Texture id 137 * @param width Texture width 138 * @param height Texture height 139 **/ 140 void Utils::framebuffer::attachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width, 141 glw::GLuint height) 142 { 143 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 144 145 bind(); 146 147 gl.bindTexture(GL_TEXTURE_2D, texture_id); 148 GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); 149 150 gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, GL_TEXTURE_2D, texture_id, 0 /* level */); 151 152 GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture2D"); 153 154 gl.viewport(0 /* x */, 0 /* y */, width, height); 155 GLU_EXPECT_NO_ERROR(gl.getError(), "Viewport"); 156 } 157 158 /** Binds framebuffer to DRAW_FRAMEBUFFER 159 * 160 **/ 161 void Utils::framebuffer::bind() 162 { 163 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 164 165 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_id); 166 GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer"); 167 } 168 169 /** Clear framebuffer 170 * 171 * @param mask <mask> parameter of glClear. Decides which shall be cleared 172 **/ 173 void Utils::framebuffer::clear(glw::GLenum mask) 174 { 175 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 176 177 gl.clear(mask); 178 GLU_EXPECT_NO_ERROR(gl.getError(), "Clear"); 179 } 180 181 /** Specifie clear color 182 * 183 * @param red Red channel 184 * @param green Green channel 185 * @param blue Blue channel 186 * @param alpha Alpha channel 187 **/ 188 void Utils::framebuffer::clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) 189 { 190 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 191 192 gl.clearColor(red, green, blue, alpha); 193 GLU_EXPECT_NO_ERROR(gl.getError(), "ClearColor"); 194 } 195 196 /** Generate framebuffer 197 * 198 **/ 199 void Utils::framebuffer::generate() 200 { 201 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 202 203 gl.genFramebuffers(1, &m_id); 204 GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers"); 205 } 206 207 const glw::GLenum Utils::program::ARB_COMPUTE_SHADER = 0x91B9; 208 209 /** Constructor. 210 * 211 * @param context CTS context. 212 **/ 213 Utils::program::program(deqp::Context& context) 214 : m_compute_shader_id(0) 215 , m_fragment_shader_id(0) 216 , m_geometry_shader_id(0) 217 , m_program_object_id(0) 218 , m_tesselation_control_shader_id(0) 219 , m_tesselation_evaluation_shader_id(0) 220 , m_vertex_shader_id(0) 221 , m_context(context) 222 { 223 /* Nothing to be done here */ 224 } 225 226 /** Destructor 227 * 228 **/ 229 Utils::program::~program() 230 { 231 remove(); 232 } 233 234 /** Build program 235 * 236 * @param compute_shader_code Compute shader source code 237 * @param fragment_shader_code Fragment shader source code 238 * @param geometry_shader_code Geometry shader source code 239 * @param tesselation_control_shader_code Tesselation control shader source code 240 * @param tesselation_evaluation_shader_code Tesselation evaluation shader source code 241 * @param vertex_shader_code Vertex shader source code 242 * @param varying_names Array of strings containing names of varyings to be captured with transfrom feedback 243 * @param n_varying_names Number of varyings to be captured with transfrom feedback 244 * @param is_separable Selects if monolithis or separable program should be built. Defaults to false 245 **/ 246 void Utils::program::build(const glw::GLchar* compute_shader_code, const glw::GLchar* fragment_shader_code, 247 const glw::GLchar* geometry_shader_code, const glw::GLchar* tesselation_control_shader_code, 248 const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code, 249 const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable) 250 { 251 /* GL entry points */ 252 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 253 254 /* Create shader objects and compile */ 255 if (0 != compute_shader_code) 256 { 257 m_compute_shader_id = gl.createShader(ARB_COMPUTE_SHADER); 258 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 259 260 compile(m_compute_shader_id, compute_shader_code); 261 } 262 263 if (0 != fragment_shader_code) 264 { 265 m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); 266 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 267 268 compile(m_fragment_shader_id, fragment_shader_code); 269 } 270 271 if (0 != geometry_shader_code) 272 { 273 m_geometry_shader_id = gl.createShader(GL_GEOMETRY_SHADER); 274 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 275 276 compile(m_geometry_shader_id, geometry_shader_code); 277 } 278 279 if (0 != tesselation_control_shader_code) 280 { 281 m_tesselation_control_shader_id = gl.createShader(GL_TESS_CONTROL_SHADER); 282 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 283 284 compile(m_tesselation_control_shader_id, tesselation_control_shader_code); 285 } 286 287 if (0 != tesselation_evaluation_shader_code) 288 { 289 m_tesselation_evaluation_shader_id = gl.createShader(GL_TESS_EVALUATION_SHADER); 290 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 291 292 compile(m_tesselation_evaluation_shader_id, tesselation_evaluation_shader_code); 293 } 294 295 if (0 != vertex_shader_code) 296 { 297 m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); 298 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 299 300 compile(m_vertex_shader_id, vertex_shader_code); 301 } 302 303 /* Create program object */ 304 m_program_object_id = gl.createProgram(); 305 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); 306 307 /* Set up captyured varyings' names */ 308 if (0 != n_varying_names) 309 { 310 gl.transformFeedbackVaryings(m_program_object_id, n_varying_names, varying_names, GL_INTERLEAVED_ATTRIBS); 311 GLU_EXPECT_NO_ERROR(gl.getError(), "TransformFeedbackVaryings"); 312 } 313 314 /* Set separable parameter */ 315 if (true == is_separable) 316 { 317 gl.programParameteri(m_program_object_id, GL_PROGRAM_SEPARABLE, GL_TRUE); 318 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramParameteri"); 319 } 320 321 /* Link program */ 322 link(); 323 } 324 325 /** Compile shader 326 * 327 * @param shader_id Shader object id 328 * @param shader_code Shader source code 329 **/ 330 void Utils::program::compile(glw::GLuint shader_id, const glw::GLchar* shader_code) const 331 { 332 /* GL entry points */ 333 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 334 335 /* Compilation status */ 336 glw::GLint status = GL_FALSE; 337 338 /* Set source code */ 339 gl.shaderSource(shader_id, 1 /* count */, &shader_code, 0); 340 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource"); 341 342 /* Compile */ 343 gl.compileShader(shader_id); 344 GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader"); 345 346 /* Get compilation status */ 347 gl.getShaderiv(shader_id, GL_COMPILE_STATUS, &status); 348 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); 349 350 /* Log compilation error */ 351 if (GL_TRUE != status) 352 { 353 glw::GLint length = 0; 354 std::vector<glw::GLchar> message; 355 356 /* Error log length */ 357 gl.getShaderiv(shader_id, GL_INFO_LOG_LENGTH, &length); 358 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); 359 360 /* Prepare storage */ 361 message.resize(length); 362 363 /* Get error log */ 364 gl.getShaderInfoLog(shader_id, length, 0, &message[0]); 365 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog"); 366 367 /* Log */ 368 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to compile shader:\n" 369 << &message[0] << "\nShader source\n" 370 << shader_code << tcu::TestLog::EndMessage; 371 372 TCU_FAIL("Failed to compile shader"); 373 } 374 } 375 376 /** Checks whether the tested driver supports GL_ARB_get_program_binary 377 * 378 * @return true if the extension is supported and, also, at least one binary format. 379 **/ 380 bool Utils::program::isProgramBinarySupported() const 381 { 382 glw::GLint n_program_binary_formats = 0; 383 384 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 385 386 if (m_context.getContextInfo().isExtensionSupported("GL_ARB_get_program_binary")) 387 { 388 gl.getIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &n_program_binary_formats); 389 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed."); 390 } 391 392 return n_program_binary_formats > 0; 393 } 394 395 /** Create program from provided binary 396 * 397 * @param binary Buffer with binary form of program 398 * @param binary_format Format of <binary> data 399 **/ 400 void Utils::program::createFromBinary(const std::vector<GLubyte>& binary, GLenum binary_format) 401 { 402 /* GL entry points */ 403 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 404 405 /* Create program object */ 406 m_program_object_id = gl.createProgram(); 407 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); 408 409 gl.programBinary(m_program_object_id, binary_format, &binary[0], (GLsizei)binary.size()); 410 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramBinary"); 411 } 412 413 /** Get binary form of program 414 * 415 * @param binary Buffer for binary data 416 * @param binary_format Format of binary data 417 **/ 418 void Utils::program::getBinary(std::vector<GLubyte>& binary, GLenum& binary_format) const 419 { 420 /* GL entry points */ 421 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 422 423 /* Get binary size */ 424 GLint length = 0; 425 gl.getProgramiv(m_program_object_id, GL_PROGRAM_BINARY_LENGTH, &length); 426 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 427 428 /* Allocate storage */ 429 binary.resize(length); 430 431 /* Get binary */ 432 gl.getProgramBinary(m_program_object_id, (GLsizei)binary.size(), &length, &binary_format, &binary[0]); 433 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramBinary"); 434 } 435 436 /** Get subroutine index 437 * 438 * @param subroutine_name Subroutine name 439 * 440 * @return Index of subroutine 441 **/ 442 GLuint Utils::program::getSubroutineIndex(const glw::GLchar* subroutine_name, glw::GLenum shader_stage) const 443 { 444 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 445 GLuint index = -1; 446 447 index = gl.getSubroutineIndex(m_program_object_id, shader_stage, subroutine_name); 448 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex"); 449 450 if (GL_INVALID_INDEX == index) 451 { 452 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine: " << subroutine_name 453 << " is not available" << tcu::TestLog::EndMessage; 454 455 TCU_FAIL("Subroutine is not available"); 456 } 457 458 return index; 459 } 460 461 /** Get subroutine uniform location 462 * 463 * @param uniform_name Subroutine uniform name 464 * 465 * @return Location of subroutine uniform 466 **/ 467 GLint Utils::program::getSubroutineUniformLocation(const glw::GLchar* uniform_name, glw::GLenum shader_stage) const 468 { 469 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 470 GLint location = -1; 471 472 location = gl.getSubroutineUniformLocation(m_program_object_id, shader_stage, uniform_name); 473 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation"); 474 475 if (-1 == location) 476 { 477 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine uniform: " << uniform_name 478 << " is not available" << tcu::TestLog::EndMessage; 479 480 TCU_FAIL("Subroutine uniform is not available"); 481 } 482 483 return location; 484 } 485 486 /** Get uniform location 487 * 488 * @param uniform_name Subroutine uniform name 489 * 490 * @return Location of uniform 491 **/ 492 GLint Utils::program::getUniformLocation(const glw::GLchar* uniform_name) const 493 { 494 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 495 GLint location = -1; 496 497 location = gl.getUniformLocation(m_program_object_id, uniform_name); 498 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); 499 500 if (-1 == location) 501 { 502 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Uniform: " << uniform_name 503 << " is not available" << tcu::TestLog::EndMessage; 504 505 TCU_FAIL("Uniform is not available"); 506 } 507 508 return location; 509 } 510 511 /** Attach shaders and link program 512 * 513 **/ 514 void Utils::program::link() const 515 { 516 /* GL entry points */ 517 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 518 519 /* Link status */ 520 glw::GLint status = GL_FALSE; 521 522 /* Attach shaders */ 523 if (0 != m_compute_shader_id) 524 { 525 gl.attachShader(m_program_object_id, m_compute_shader_id); 526 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 527 } 528 529 if (0 != m_fragment_shader_id) 530 { 531 gl.attachShader(m_program_object_id, m_fragment_shader_id); 532 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 533 } 534 535 if (0 != m_geometry_shader_id) 536 { 537 gl.attachShader(m_program_object_id, m_geometry_shader_id); 538 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 539 } 540 541 if (0 != m_tesselation_control_shader_id) 542 { 543 gl.attachShader(m_program_object_id, m_tesselation_control_shader_id); 544 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 545 } 546 547 if (0 != m_tesselation_evaluation_shader_id) 548 { 549 gl.attachShader(m_program_object_id, m_tesselation_evaluation_shader_id); 550 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 551 } 552 553 if (0 != m_vertex_shader_id) 554 { 555 gl.attachShader(m_program_object_id, m_vertex_shader_id); 556 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 557 } 558 559 /* Link */ 560 gl.linkProgram(m_program_object_id); 561 GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram"); 562 563 /* Get link status */ 564 gl.getProgramiv(m_program_object_id, GL_LINK_STATUS, &status); 565 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 566 567 /* Log link error */ 568 if (GL_TRUE != status) 569 { 570 glw::GLint length = 0; 571 std::vector<glw::GLchar> message; 572 573 /* Get error log length */ 574 gl.getProgramiv(m_program_object_id, GL_INFO_LOG_LENGTH, &length); 575 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 576 577 message.resize(length); 578 579 /* Get error log */ 580 gl.getProgramInfoLog(m_program_object_id, length, 0, &message[0]); 581 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); 582 583 /* Log */ 584 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to link program:\n" 585 << &message[0] << tcu::TestLog::EndMessage; 586 587 TCU_FAIL("Failed to link program"); 588 } 589 } 590 591 /** Delete program object and all attached shaders 592 * 593 **/ 594 void Utils::program::remove() 595 { 596 /* GL entry points */ 597 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 598 599 /* Make sure program object is no longer used by GL */ 600 gl.useProgram(0); 601 602 /* Clean program object */ 603 if (0 != m_program_object_id) 604 { 605 gl.deleteProgram(m_program_object_id); 606 m_program_object_id = 0; 607 } 608 609 /* Clean shaders */ 610 if (0 != m_compute_shader_id) 611 { 612 gl.deleteShader(m_compute_shader_id); 613 m_compute_shader_id = 0; 614 } 615 616 if (0 != m_fragment_shader_id) 617 { 618 gl.deleteShader(m_fragment_shader_id); 619 m_fragment_shader_id = 0; 620 } 621 622 if (0 != m_geometry_shader_id) 623 { 624 gl.deleteShader(m_geometry_shader_id); 625 m_geometry_shader_id = 0; 626 } 627 628 if (0 != m_tesselation_control_shader_id) 629 { 630 gl.deleteShader(m_tesselation_control_shader_id); 631 m_tesselation_control_shader_id = 0; 632 } 633 634 if (0 != m_tesselation_evaluation_shader_id) 635 { 636 gl.deleteShader(m_tesselation_evaluation_shader_id); 637 m_tesselation_evaluation_shader_id = 0; 638 } 639 640 if (0 != m_vertex_shader_id) 641 { 642 gl.deleteShader(m_vertex_shader_id); 643 m_vertex_shader_id = 0; 644 } 645 } 646 647 /** Execute UseProgram 648 * 649 **/ 650 void Utils::program::use() const 651 { 652 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 653 654 gl.useProgram(m_program_object_id); 655 GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); 656 } 657 658 /** Constructor. 659 * 660 * @param context CTS context. 661 **/ 662 Utils::texture::texture(deqp::Context& context) : m_id(0), m_context(context) 663 { 664 /* Nothing to done here */ 665 } 666 667 /** Destructor 668 * 669 **/ 670 Utils::texture::~texture() 671 { 672 if (0 != m_id) 673 { 674 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 675 676 gl.deleteTextures(1, &m_id); 677 m_id = 0; 678 } 679 } 680 681 /** Bind texture to GL_TEXTURE_2D 682 * 683 **/ 684 void Utils::texture::bind() 685 { 686 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 687 688 gl.bindTexture(GL_TEXTURE_2D, m_id); 689 GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); 690 } 691 692 /** Create 2d texture 693 * 694 * @param width Width of texture 695 * @param height Height of texture 696 * @param internal_format Internal format of texture 697 **/ 698 void Utils::texture::create(glw::GLuint width, glw::GLuint height, glw::GLenum internal_format) 699 { 700 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 701 702 gl.genTextures(1, &m_id); 703 GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); 704 705 bind(); 706 707 gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, internal_format, width, height); 708 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D"); 709 } 710 711 /** Get contents of texture 712 * 713 * @param format Format of image 714 * @param type Type of image 715 * @param out_data Buffer for image 716 **/ 717 void Utils::texture::get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data) 718 { 719 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 720 721 bind(); 722 723 gl.getTexImage(GL_TEXTURE_2D, 0, format, type, out_data); 724 GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage"); 725 } 726 727 /** Update contents of texture 728 * 729 * @param width Width of texture 730 * @param height Height of texture 731 * @param format Format of data 732 * @param type Type of data 733 * @param data Buffer with image 734 **/ 735 void Utils::texture::update(glw::GLuint width, glw::GLuint height, glw::GLenum format, glw::GLenum type, 736 glw::GLvoid* data) 737 { 738 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 739 740 bind(); 741 742 gl.texSubImage2D(GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */, width, height, format, type, data); 743 GLU_EXPECT_NO_ERROR(gl.getError(), "TexSubImage2D"); 744 } 745 746 /** Constructor. 747 * 748 * @param context CTS context. 749 **/ 750 Utils::vertexArray::vertexArray(deqp::Context& context) : m_id(0), m_context(context) 751 { 752 } 753 754 /** Destructor 755 * 756 **/ 757 Utils::vertexArray::~vertexArray() 758 { 759 if (0 != m_id) 760 { 761 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 762 763 gl.deleteVertexArrays(1, &m_id); 764 765 m_id = 0; 766 } 767 } 768 769 /** Execute BindVertexArray 770 * 771 **/ 772 void Utils::vertexArray::bind() 773 { 774 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 775 776 gl.bindVertexArray(m_id); 777 GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); 778 } 779 780 /** Execute GenVertexArrays 781 * 782 **/ 783 void Utils::vertexArray::generate() 784 { 785 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 786 787 gl.genVertexArrays(1, &m_id); 788 GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); 789 } 790 791 /** Builds a program object consisting of up to 5 shader stages 792 * (vertex/tessellation control/tessellation evaluation/geometry/fragment). 793 * The shaders are attached to the program object, then compiled. Finally, 794 * the program object is linked. 795 * 796 * XFB can be optionally configured for the program object. 797 * 798 * Should an error be reported by GL implementation, a TestError 799 * exception will be thrown. 800 * 801 * @param gl OpenGL functions from the active rendering context. 802 * @param vs_body Body to use for the vertex shader. Can be an empty string. 803 * @param tc_body Body to use for the tessellation control shader. Can be 804 * an empty string. 805 * @param te_body Body to use for the tessellation evaluation shader. Can be 806 * an empty string. 807 * @param gs_body Body to use for the geometry shader. Can be an empty string. 808 * @param fs_body Body to use for the fragment shader. Can be an empty string. 809 * @param xfb_varyings An array of names of varyings to use for XFB. Can be NULL. 810 * @param n_xfb_varyings Amount of XFB varyings defined in @param xfb_varyings.Can be 0. 811 * @param out_vs_id Deref will be used to store GL id of a generated vertex shader. 812 * Can be NULL in which case no vertex shader will be used for the 813 * program object. 814 * @param out_tc_id Deref will be used to store GL id of a generated tess control shader. 815 * Can be NULL in which case no tess control shader will be used for the 816 * program object. 817 * @param out_te_id Deref will be used to store GL id of a generated tess evaluation shader. 818 * Can be NULL in which case no tess evaluation shader will be used for the 819 * program object. 820 * @param out_gs_id Deref will be used to store GL id of a generated geometry shader. 821 * Can be NULL in which case no geometry shader will be used for the 822 * program object. 823 * @param out_fs_id Deref will be used to store GL id of a generated fragment shader. 824 * Can be NULL in which case no fragment shader will be used for the 825 * program object. 826 * @param out_po_id Deref will be used to store GL id of a generated program object. 827 * Must not be NULL. 828 * 829 * @return true if the program was built successfully, false otherwise. 830 * */ 831 bool Utils::buildProgram(const glw::Functions& gl, const std::string& vs_body, const std::string& tc_body, 832 const std::string& te_body, const std::string& gs_body, const std::string& fs_body, 833 const glw::GLchar** xfb_varyings, const unsigned int& n_xfb_varyings, glw::GLuint* out_vs_id, 834 glw::GLuint* out_tc_id, glw::GLuint* out_te_id, glw::GLuint* out_gs_id, glw::GLuint* out_fs_id, 835 glw::GLuint* out_po_id) 836 { 837 bool result = false; 838 839 /* Link the program object */ 840 glw::GLint link_status = GL_FALSE; 841 842 /* Create objects, set up shader bodies and attach all requested shaders to the program object */ 843 *out_po_id = gl.createProgram(); 844 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); 845 846 if (out_vs_id != DE_NULL) 847 { 848 const char* vs_body_raw_ptr = vs_body.c_str(); 849 850 *out_vs_id = gl.createShader(GL_VERTEX_SHADER); 851 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 852 853 gl.attachShader(*out_po_id, *out_vs_id); 854 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 855 856 gl.shaderSource(*out_vs_id, 1 /* count */, &vs_body_raw_ptr, DE_NULL /* length */); 857 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 858 } 859 860 if (out_tc_id != DE_NULL) 861 { 862 const char* tc_body_raw_ptr = tc_body.c_str(); 863 864 *out_tc_id = gl.createShader(GL_TESS_CONTROL_SHADER); 865 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 866 867 gl.attachShader(*out_po_id, *out_tc_id); 868 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 869 870 gl.shaderSource(*out_tc_id, 1 /* count */, &tc_body_raw_ptr, DE_NULL /* length */); 871 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 872 } 873 874 if (out_te_id != DE_NULL) 875 { 876 const char* te_body_raw_ptr = te_body.c_str(); 877 878 *out_te_id = gl.createShader(GL_TESS_EVALUATION_SHADER); 879 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 880 881 gl.attachShader(*out_po_id, *out_te_id); 882 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 883 884 gl.shaderSource(*out_te_id, 1 /* count */, &te_body_raw_ptr, DE_NULL /* length */); 885 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 886 } 887 888 if (out_gs_id != DE_NULL) 889 { 890 const char* gs_body_raw_ptr = gs_body.c_str(); 891 892 *out_gs_id = gl.createShader(GL_GEOMETRY_SHADER); 893 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 894 895 gl.attachShader(*out_po_id, *out_gs_id); 896 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 897 898 gl.shaderSource(*out_gs_id, 1 /* count */, &gs_body_raw_ptr, DE_NULL /* length */); 899 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 900 } 901 902 if (out_fs_id != DE_NULL) 903 { 904 const char* fs_body_raw_ptr = fs_body.c_str(); 905 906 *out_fs_id = gl.createShader(GL_FRAGMENT_SHADER); 907 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 908 909 gl.attachShader(*out_po_id, *out_fs_id); 910 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 911 912 gl.shaderSource(*out_fs_id, 1 /* count */, &fs_body_raw_ptr, DE_NULL /* length */); 913 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 914 } 915 916 /* Compile all shaders */ 917 const glw::GLuint so_ids[] = { (out_vs_id != DE_NULL) ? *out_vs_id : 0, (out_tc_id != DE_NULL) ? *out_tc_id : 0, 918 (out_te_id != DE_NULL) ? *out_te_id : 0, (out_gs_id != DE_NULL) ? *out_gs_id : 0, 919 (out_fs_id != DE_NULL) ? *out_fs_id : 0 }; 920 const unsigned int n_so_ids = sizeof(so_ids) / sizeof(so_ids[0]); 921 922 for (unsigned int n_so_id = 0; n_so_id < n_so_ids; ++n_so_id) 923 { 924 glw::GLuint so_id = so_ids[n_so_id]; 925 926 if (so_id != 0) 927 { 928 glw::GLint compile_status = GL_FALSE; 929 930 gl.compileShader(so_id); 931 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); 932 933 gl.getShaderiv(so_id, GL_COMPILE_STATUS, &compile_status); 934 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 935 936 if (compile_status != GL_TRUE) 937 { 938 goto end; 939 } 940 } /* if (so_id != 0) */ 941 } /* for (all shader objects) */ 942 943 /* Set up XFB */ 944 if (xfb_varyings != NULL) 945 { 946 gl.transformFeedbackVaryings(*out_po_id, n_xfb_varyings, xfb_varyings, GL_INTERLEAVED_ATTRIBS); 947 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed."); 948 } 949 950 gl.linkProgram(*out_po_id); 951 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); 952 953 gl.getProgramiv(*out_po_id, GL_LINK_STATUS, &link_status); 954 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 955 956 if (link_status != GL_TRUE) 957 { 958 goto end; 959 } 960 961 /* All done */ 962 result = true; 963 964 end: 965 return result; 966 } 967 968 /** Retrieves base variable type for user-specified variable type 969 * (eg. float for vec4) 970 * 971 * @param variable_type Variable type to use for the query. 972 * 973 * @return As per description. 974 **/ 975 Utils::_variable_type Utils::getBaseVariableType(const _variable_type& variable_type) 976 { 977 _variable_type result = VARIABLE_TYPE_UNKNOWN; 978 979 switch (variable_type) 980 { 981 case VARIABLE_TYPE_BOOL: 982 case VARIABLE_TYPE_BVEC2: 983 case VARIABLE_TYPE_BVEC3: 984 case VARIABLE_TYPE_BVEC4: 985 { 986 result = VARIABLE_TYPE_BOOL; 987 988 break; 989 } 990 991 case VARIABLE_TYPE_DOUBLE: 992 case VARIABLE_TYPE_DVEC2: 993 case VARIABLE_TYPE_DVEC3: 994 case VARIABLE_TYPE_DVEC4: 995 { 996 result = VARIABLE_TYPE_DOUBLE; 997 998 break; 999 } 1000 1001 case VARIABLE_TYPE_FLOAT: 1002 case VARIABLE_TYPE_MAT2: 1003 case VARIABLE_TYPE_MAT2X3: 1004 case VARIABLE_TYPE_MAT2X4: 1005 case VARIABLE_TYPE_MAT3: 1006 case VARIABLE_TYPE_MAT3X2: 1007 case VARIABLE_TYPE_MAT3X4: 1008 case VARIABLE_TYPE_MAT4: 1009 case VARIABLE_TYPE_MAT4X2: 1010 case VARIABLE_TYPE_MAT4X3: 1011 case VARIABLE_TYPE_VEC2: 1012 case VARIABLE_TYPE_VEC3: 1013 case VARIABLE_TYPE_VEC4: 1014 { 1015 result = VARIABLE_TYPE_FLOAT; 1016 1017 break; 1018 } 1019 1020 case VARIABLE_TYPE_INT: 1021 case VARIABLE_TYPE_IVEC2: 1022 case VARIABLE_TYPE_IVEC3: 1023 case VARIABLE_TYPE_IVEC4: 1024 { 1025 result = VARIABLE_TYPE_INT; 1026 1027 break; 1028 } 1029 1030 case VARIABLE_TYPE_UINT: 1031 case VARIABLE_TYPE_UVEC2: 1032 case VARIABLE_TYPE_UVEC3: 1033 case VARIABLE_TYPE_UVEC4: 1034 { 1035 result = VARIABLE_TYPE_UINT; 1036 1037 break; 1038 } 1039 1040 default: 1041 { 1042 TCU_FAIL("Unrecognized variable type"); 1043 } 1044 } /* switch (variable_type) */ 1045 1046 return result; 1047 } 1048 1049 /** Retrieves size of a single component (in bytes) for user-specified 1050 * variable type. 1051 * 1052 * @param variable_type Variable type to use for the query. 1053 * 1054 * @return As per description. 1055 **/ 1056 unsigned int Utils::getComponentSizeForVariableType(const _variable_type& variable_type) 1057 { 1058 _variable_type base_variable_type = getBaseVariableType(variable_type); 1059 unsigned int result = 0; 1060 1061 switch (base_variable_type) 1062 { 1063 case VARIABLE_TYPE_BOOL: 1064 result = sizeof(bool); 1065 break; 1066 case VARIABLE_TYPE_DOUBLE: 1067 result = sizeof(double); 1068 break; 1069 case VARIABLE_TYPE_FLOAT: 1070 result = sizeof(float); 1071 break; 1072 case VARIABLE_TYPE_INT: 1073 result = sizeof(int); 1074 break; 1075 case VARIABLE_TYPE_UINT: 1076 result = sizeof(unsigned int); 1077 break; 1078 1079 default: 1080 { 1081 TCU_FAIL("Unrecognized base variable type"); 1082 } 1083 } /* switch (variable_type) */ 1084 1085 return result; 1086 } 1087 1088 /** Retrieves a GLenum value corresponding to internal shader stage 1089 * representation. 1090 * 1091 * @param shader_stage Shader stage to user for the query. 1092 * 1093 * @return Requested value or GL_NONE if the stage was not recognized. 1094 **/ 1095 glw::GLenum Utils::getGLenumForShaderStage(const _shader_stage& shader_stage) 1096 { 1097 glw::GLenum result = GL_NONE; 1098 1099 switch (shader_stage) 1100 { 1101 case SHADER_STAGE_VERTEX: 1102 result = GL_VERTEX_SHADER; 1103 break; 1104 case SHADER_STAGE_TESSELLATION_CONTROL: 1105 result = GL_TESS_CONTROL_SHADER; 1106 break; 1107 case SHADER_STAGE_TESSELLATION_EVALUATION: 1108 result = GL_TESS_EVALUATION_SHADER; 1109 break; 1110 case SHADER_STAGE_GEOMETRY: 1111 result = GL_GEOMETRY_SHADER; 1112 break; 1113 case SHADER_STAGE_FRAGMENT: 1114 result = GL_FRAGMENT_SHADER; 1115 break; 1116 1117 default: 1118 { 1119 TCU_FAIL("Unrecognized shader stage requested"); 1120 } 1121 } /* switch (shader_stage) */ 1122 1123 return result; 1124 } 1125 1126 /** Retrieves number of components that user-specified variable type supports. 1127 * 1128 * @param variable_type GLSL variable type to use for the query. 1129 * 1130 * @return As per description. 1131 **/ 1132 unsigned int Utils::getNumberOfComponentsForVariableType(const _variable_type& variable_type) 1133 { 1134 unsigned int result = 0; 1135 1136 switch (variable_type) 1137 { 1138 case VARIABLE_TYPE_BOOL: 1139 case VARIABLE_TYPE_DOUBLE: 1140 case VARIABLE_TYPE_FLOAT: 1141 case VARIABLE_TYPE_INT: 1142 case VARIABLE_TYPE_UINT: 1143 { 1144 result = 1; 1145 1146 break; 1147 } 1148 1149 case VARIABLE_TYPE_BVEC2: 1150 case VARIABLE_TYPE_DVEC2: 1151 case VARIABLE_TYPE_IVEC2: 1152 case VARIABLE_TYPE_UVEC2: 1153 case VARIABLE_TYPE_VEC2: 1154 { 1155 result = 2; 1156 1157 break; 1158 } 1159 1160 case VARIABLE_TYPE_BVEC3: 1161 case VARIABLE_TYPE_DVEC3: 1162 case VARIABLE_TYPE_IVEC3: 1163 case VARIABLE_TYPE_UVEC3: 1164 case VARIABLE_TYPE_VEC3: 1165 { 1166 result = 3; 1167 1168 break; 1169 } 1170 1171 case VARIABLE_TYPE_BVEC4: 1172 case VARIABLE_TYPE_DVEC4: 1173 case VARIABLE_TYPE_IVEC4: 1174 case VARIABLE_TYPE_MAT2: 1175 case VARIABLE_TYPE_UVEC4: 1176 case VARIABLE_TYPE_VEC4: 1177 { 1178 result = 4; 1179 1180 break; 1181 } 1182 1183 case VARIABLE_TYPE_MAT2X3: 1184 case VARIABLE_TYPE_MAT3X2: 1185 { 1186 result = 6; 1187 1188 break; 1189 } 1190 1191 case VARIABLE_TYPE_MAT2X4: 1192 case VARIABLE_TYPE_MAT4X2: 1193 { 1194 result = 8; 1195 1196 break; 1197 } 1198 1199 case VARIABLE_TYPE_MAT3: 1200 { 1201 result = 9; 1202 1203 break; 1204 } 1205 1206 case VARIABLE_TYPE_MAT3X4: 1207 case VARIABLE_TYPE_MAT4X3: 1208 { 1209 result = 12; 1210 1211 break; 1212 } 1213 1214 case VARIABLE_TYPE_MAT4: 1215 { 1216 result = 16; 1217 1218 break; 1219 } 1220 1221 default: 1222 break; 1223 } /* switch (variable_type) */ 1224 1225 return result; 1226 } 1227 1228 /** Retrieves a literal defining user-specified shader stage enum. 1229 * 1230 * @param shader_stage Shader stage to use for the query. 1231 * 1232 * @return Requested string or "?" if the stage was not recognized. 1233 **/ 1234 std::string Utils::getShaderStageString(const _shader_stage& shader_stage) 1235 { 1236 std::string result = "?"; 1237 1238 switch (shader_stage) 1239 { 1240 case SHADER_STAGE_FRAGMENT: 1241 result = "Fragment Shader"; 1242 break; 1243 case SHADER_STAGE_GEOMETRY: 1244 result = "Geometry Shader"; 1245 break; 1246 case SHADER_STAGE_TESSELLATION_CONTROL: 1247 result = "Tessellation Control Shader"; 1248 break; 1249 case SHADER_STAGE_TESSELLATION_EVALUATION: 1250 result = "Tessellation Evaluation Shader"; 1251 break; 1252 case SHADER_STAGE_VERTEX: 1253 result = "Vertex Shader"; 1254 break; 1255 1256 default: 1257 { 1258 TCU_FAIL("Unrecognized shader stage"); 1259 } 1260 } /* switch (shader_stage) */ 1261 1262 return result; 1263 } 1264 1265 /** Retrieves a literal defining user-specified shader stage enum. 1266 * 1267 * @param shader_stage_glenum Shader stage to use for the query. 1268 * 1269 * @return Requested string or "?" if the stage was not recognized. 1270 **/ 1271 std::string Utils::getShaderStageStringFromGLEnum(const glw::GLenum shader_stage_glenum) 1272 { 1273 std::string result = "?"; 1274 1275 switch (shader_stage_glenum) 1276 { 1277 case GL_FRAGMENT_SHADER: 1278 result = "Fragment Shader"; 1279 break; 1280 case GL_GEOMETRY_SHADER: 1281 result = "Geometry Shader"; 1282 break; 1283 case GL_TESS_CONTROL_SHADER: 1284 result = "Tessellation Control Shader"; 1285 break; 1286 case GL_TESS_EVALUATION_SHADER: 1287 result = "Tessellation Evaluation Shader"; 1288 break; 1289 case GL_VERTEX_SHADER: 1290 result = "Vertex Shader"; 1291 break; 1292 1293 default: 1294 { 1295 TCU_FAIL("Unrecognized shader string"); 1296 } 1297 } /* switch (shader_stage_glenum) */ 1298 1299 return result; 1300 } 1301 1302 /** Returns string that represents program interface name 1303 * 1304 * @param program_interface Program interface 1305 * 1306 * @return String representation of known program interface 1307 **/ 1308 const GLchar* Utils::programInterfaceToStr(glw::GLenum program_interface) 1309 { 1310 const GLchar* string = "Unknown program interface"; 1311 1312 switch (program_interface) 1313 { 1314 case GL_VERTEX_SUBROUTINE: 1315 string = "GL_VERTEX_SUBROUTINE"; 1316 break; 1317 case GL_VERTEX_SUBROUTINE_UNIFORM: 1318 string = "GL_VERTEX_SUBROUTINE_UNIFORM"; 1319 break; 1320 default: 1321 TCU_FAIL("Not implemented"); 1322 break; 1323 }; 1324 1325 return string; 1326 } 1327 1328 /** Returns string that represents pname's name 1329 * 1330 * @param pname pname 1331 * 1332 * @return String representation of known pnames 1333 **/ 1334 const GLchar* Utils::pnameToStr(glw::GLenum pname) 1335 { 1336 const GLchar* string = "Unknown pname"; 1337 1338 switch (pname) 1339 { 1340 case GL_ACTIVE_SUBROUTINE_UNIFORMS: 1341 string = "GL_ACTIVE_SUBROUTINE_UNIFORMS"; 1342 break; 1343 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS: 1344 string = "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS"; 1345 break; 1346 case GL_ACTIVE_SUBROUTINES: 1347 string = "GL_ACTIVE_SUBROUTINES"; 1348 break; 1349 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH: 1350 string = "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH"; 1351 break; 1352 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH: 1353 string = "GL_ACTIVE_SUBROUTINE_MAX_LENGTH"; 1354 break; 1355 case GL_NUM_COMPATIBLE_SUBROUTINES: 1356 string = "GL_NUM_COMPATIBLE_SUBROUTINES"; 1357 break; 1358 case GL_UNIFORM_SIZE: 1359 string = "GL_UNIFORM_SIZE"; 1360 break; 1361 case GL_COMPATIBLE_SUBROUTINES: 1362 string = "GL_COMPATIBLE_SUBROUTINES"; 1363 break; 1364 case GL_UNIFORM_NAME_LENGTH: 1365 string = "GL_UNIFORM_NAME_LENGTH"; 1366 break; 1367 case GL_ACTIVE_RESOURCES: 1368 string = "GL_ACTIVE_RESOURCES"; 1369 break; 1370 case GL_MAX_NAME_LENGTH: 1371 string = "GL_MAX_NAME_LENGTH"; 1372 break; 1373 case GL_MAX_NUM_COMPATIBLE_SUBROUTINES: 1374 string = "GL_MAX_NUM_COMPATIBLE_SUBROUTINES"; 1375 break; 1376 case GL_NAME_LENGTH: 1377 string = "GL_NAME_LENGTH"; 1378 break; 1379 case GL_ARRAY_SIZE: 1380 string = "GL_ARRAY_SIZE"; 1381 break; 1382 case GL_LOCATION: 1383 string = "GL_LOCATION"; 1384 break; 1385 default: 1386 TCU_FAIL("Not implemented"); 1387 break; 1388 }; 1389 1390 return string; 1391 } 1392 1393 bool Utils::compare(const glw::GLfloat& left, const glw::GLfloat& right) 1394 { 1395 static const glw::GLfloat m_epsilon = 0.00001f; 1396 1397 if (m_epsilon < std::abs(right - left)) 1398 { 1399 return false; 1400 } 1401 else 1402 { 1403 return true; 1404 } 1405 } 1406 1407 /** Returns a variable type enum corresponding to user-specified base variable type 1408 * and the number of components it should support. 1409 * 1410 * @param base_variable_type Base variable type to use for the query. 1411 * @param n_components Number of components to consider for the query. 1412 * 1413 * @return As per description. 1414 **/ 1415 Utils::_variable_type Utils::getVariableTypeFromProperties(const _variable_type& base_variable_type, 1416 const unsigned int& n_components) 1417 { 1418 _variable_type result = VARIABLE_TYPE_UNKNOWN; 1419 1420 switch (base_variable_type) 1421 { 1422 case VARIABLE_TYPE_BOOL: 1423 { 1424 switch (n_components) 1425 { 1426 case 1: 1427 result = VARIABLE_TYPE_BOOL; 1428 break; 1429 case 2: 1430 result = VARIABLE_TYPE_BVEC2; 1431 break; 1432 case 3: 1433 result = VARIABLE_TYPE_BVEC3; 1434 break; 1435 case 4: 1436 result = VARIABLE_TYPE_BVEC4; 1437 break; 1438 1439 default: 1440 { 1441 TCU_FAIL("Unsupported number of components requested"); 1442 } 1443 } /* switch (n_components) */ 1444 1445 break; 1446 } 1447 1448 case VARIABLE_TYPE_DOUBLE: 1449 { 1450 switch (n_components) 1451 { 1452 case 1: 1453 result = VARIABLE_TYPE_DOUBLE; 1454 break; 1455 case 2: 1456 result = VARIABLE_TYPE_DVEC2; 1457 break; 1458 case 3: 1459 result = VARIABLE_TYPE_DVEC3; 1460 break; 1461 case 4: 1462 result = VARIABLE_TYPE_DVEC4; 1463 break; 1464 1465 default: 1466 { 1467 TCU_FAIL("Unsupported number of components requested"); 1468 } 1469 } /* switch (n_components) */ 1470 1471 break; 1472 } 1473 1474 case VARIABLE_TYPE_FLOAT: 1475 { 1476 switch (n_components) 1477 { 1478 case 1: 1479 result = VARIABLE_TYPE_FLOAT; 1480 break; 1481 case 2: 1482 result = VARIABLE_TYPE_VEC2; 1483 break; 1484 case 3: 1485 result = VARIABLE_TYPE_VEC3; 1486 break; 1487 case 4: 1488 result = VARIABLE_TYPE_VEC4; 1489 break; 1490 1491 default: 1492 { 1493 TCU_FAIL("Unsupported number of components requested"); 1494 } 1495 } /* switch (n_components) */ 1496 1497 break; 1498 } 1499 1500 case VARIABLE_TYPE_INT: 1501 { 1502 switch (n_components) 1503 { 1504 case 1: 1505 result = VARIABLE_TYPE_INT; 1506 break; 1507 case 2: 1508 result = VARIABLE_TYPE_IVEC2; 1509 break; 1510 case 3: 1511 result = VARIABLE_TYPE_IVEC3; 1512 break; 1513 case 4: 1514 result = VARIABLE_TYPE_IVEC4; 1515 break; 1516 1517 default: 1518 { 1519 TCU_FAIL("Unsupported number of components requested"); 1520 } 1521 } /* switch (n_components) */ 1522 1523 break; 1524 } 1525 1526 case VARIABLE_TYPE_UINT: 1527 { 1528 switch (n_components) 1529 { 1530 case 1: 1531 result = VARIABLE_TYPE_UINT; 1532 break; 1533 case 2: 1534 result = VARIABLE_TYPE_UVEC2; 1535 break; 1536 case 3: 1537 result = VARIABLE_TYPE_UVEC3; 1538 break; 1539 case 4: 1540 result = VARIABLE_TYPE_UVEC4; 1541 break; 1542 1543 default: 1544 { 1545 TCU_FAIL("Unsupported number of components requested"); 1546 } 1547 } /* switch (n_components) */ 1548 1549 break; 1550 } 1551 1552 default: 1553 { 1554 TCU_FAIL("Unrecognized base variable type"); 1555 } 1556 } /* switch (base_variable_type) */ 1557 1558 return result; 1559 } 1560 1561 /** Returns a GLSL literal corresponding to user-specified variable type. 1562 * 1563 * @param variable_type Variable type to use for the query. 1564 * 1565 * @return As per description or [?] if @param variable_type was not 1566 * recognized. 1567 **/ 1568 std::string Utils::getVariableTypeGLSLString(const _variable_type& variable_type) 1569 { 1570 std::string result = "[?]"; 1571 1572 switch (variable_type) 1573 { 1574 case VARIABLE_TYPE_BOOL: 1575 result = "bool"; 1576 break; 1577 case VARIABLE_TYPE_BVEC2: 1578 result = "bvec2"; 1579 break; 1580 case VARIABLE_TYPE_BVEC3: 1581 result = "bvec3"; 1582 break; 1583 case VARIABLE_TYPE_BVEC4: 1584 result = "bvec4"; 1585 break; 1586 case VARIABLE_TYPE_DOUBLE: 1587 result = "double"; 1588 break; 1589 case VARIABLE_TYPE_DVEC2: 1590 result = "dvec2"; 1591 break; 1592 case VARIABLE_TYPE_DVEC3: 1593 result = "dvec3"; 1594 break; 1595 case VARIABLE_TYPE_DVEC4: 1596 result = "dvec4"; 1597 break; 1598 case VARIABLE_TYPE_FLOAT: 1599 result = "float"; 1600 break; 1601 case VARIABLE_TYPE_INT: 1602 result = "int"; 1603 break; 1604 case VARIABLE_TYPE_IVEC2: 1605 result = "ivec2"; 1606 break; 1607 case VARIABLE_TYPE_IVEC3: 1608 result = "ivec3"; 1609 break; 1610 case VARIABLE_TYPE_IVEC4: 1611 result = "ivec4"; 1612 break; 1613 case VARIABLE_TYPE_MAT2: 1614 result = "mat2"; 1615 break; 1616 case VARIABLE_TYPE_MAT2X3: 1617 result = "mat2x3"; 1618 break; 1619 case VARIABLE_TYPE_MAT2X4: 1620 result = "mat2x4"; 1621 break; 1622 case VARIABLE_TYPE_MAT3: 1623 result = "mat3"; 1624 break; 1625 case VARIABLE_TYPE_MAT3X2: 1626 result = "mat3x2"; 1627 break; 1628 case VARIABLE_TYPE_MAT3X4: 1629 result = "mat3x4"; 1630 break; 1631 case VARIABLE_TYPE_MAT4: 1632 result = "mat4"; 1633 break; 1634 case VARIABLE_TYPE_MAT4X2: 1635 result = "mat4x2"; 1636 break; 1637 case VARIABLE_TYPE_MAT4X3: 1638 result = "mat4x3"; 1639 break; 1640 case VARIABLE_TYPE_UINT: 1641 result = "uint"; 1642 break; 1643 case VARIABLE_TYPE_UVEC2: 1644 result = "uvec2"; 1645 break; 1646 case VARIABLE_TYPE_UVEC3: 1647 result = "uvec3"; 1648 break; 1649 case VARIABLE_TYPE_UVEC4: 1650 result = "uvec4"; 1651 break; 1652 case VARIABLE_TYPE_VEC2: 1653 result = "vec2"; 1654 break; 1655 case VARIABLE_TYPE_VEC3: 1656 result = "vec3"; 1657 break; 1658 case VARIABLE_TYPE_VEC4: 1659 result = "vec4"; 1660 break; 1661 1662 default: 1663 { 1664 TCU_FAIL("Unrecognized variable type"); 1665 } 1666 } /* switch (variable_type) */ 1667 1668 return result; 1669 } 1670 1671 /** Constructor. 1672 * 1673 * @param context Rendering context. 1674 * 1675 **/ 1676 APITest1::APITest1(deqp::Context& context) 1677 : TestCase(context, "min_maxes", "Verifies the implementation returns valid GL_MAX_SUBROUTINE* pnames " 1678 "which meet the minimum maximum requirements enforced by the spec.") 1679 , m_has_test_passed(true) 1680 { 1681 /* Left blank intentionally */ 1682 } 1683 1684 /** Executes test iteration. 1685 * 1686 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 1687 */ 1688 tcu::TestNode::IterateResult APITest1::iterate() 1689 { 1690 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1691 1692 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 1693 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 1694 { 1695 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 1696 } 1697 1698 /* Iterate over all pnames */ 1699 const struct 1700 { 1701 glw::GLenum pname; 1702 const char* pname_string; 1703 glw::GLint min_value; 1704 } pnames[] = { { GL_MAX_SUBROUTINES, "GL_MAX_SUBROUTINES", 256 }, 1705 { GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS, "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS", 1024 } }; 1706 const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]); 1707 1708 for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname) 1709 { 1710 glw::GLboolean bool_value = GL_FALSE; 1711 glw::GLdouble double_value = 0.0; 1712 glw::GLfloat float_value = 0.0f; 1713 glw::GLint int_value = 0; 1714 glw::GLint64 int64_value = 0; 1715 const glw::GLint min_value = pnames[n_pname].min_value; 1716 const glw::GLenum& pname = pnames[n_pname].pname; 1717 const char* pname_string = pnames[n_pname].pname_string; 1718 1719 /* Retrieve the pname values */ 1720 gl.getBooleanv(pname, &bool_value); 1721 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() call failed."); 1722 1723 gl.getDoublev(pname, &double_value); 1724 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetDoublev() call failed."); 1725 1726 gl.getFloatv(pname, &float_value); 1727 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() call failed."); 1728 1729 gl.getIntegerv(pname, &int_value); 1730 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed."); 1731 1732 gl.getInteger64v(pname, &int64_value); 1733 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetInteger64v() call failed."); 1734 1735 /* Make sure the value reported meets the min max requirement */ 1736 if (int_value < min_value) 1737 { 1738 m_testCtx.getLog() << tcu::TestLog::Message << "GL implementation reports a value of [" << int_value 1739 << "]" 1740 " for property [" 1741 << pname_string << "]" 1742 ", whereas the min max for the property is [" 1743 << min_value << "]." << tcu::TestLog::EndMessage; 1744 1745 m_has_test_passed = false; 1746 } 1747 1748 /* Verify the other getters reported valid values */ 1749 const float epsilon = 1e-5f; 1750 1751 if (((int_value == 0) && (bool_value == GL_TRUE)) || ((int_value != 0) && (bool_value != GL_TRUE))) 1752 { 1753 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid boolean value [" << bool_value 1754 << "]" 1755 " reported for property [" 1756 << pname_string << "]" 1757 " (int value:[" 1758 << int_value << "])" << tcu::TestLog::EndMessage; 1759 1760 m_has_test_passed = false; 1761 } 1762 1763 if (de::abs(double_value - (double)int_value) > epsilon) 1764 { 1765 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid double value [" << double_value 1766 << "]" 1767 " reported for property [" 1768 << pname_string << "]" 1769 " (int value:[" 1770 << int_value << "])" << tcu::TestLog::EndMessage; 1771 1772 m_has_test_passed = false; 1773 } 1774 1775 if (de::abs(float_value - (float)int_value) > epsilon) 1776 { 1777 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid float value [" << float_value 1778 << "]" 1779 " reported for property [" 1780 << pname_string << "]" 1781 " (int value:[" 1782 << int_value << "])" << tcu::TestLog::EndMessage; 1783 1784 m_has_test_passed = false; 1785 } 1786 1787 if (int64_value != int_value) 1788 { 1789 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid 64-bit integer value [" << float_value 1790 << "]" 1791 " reported for property [" 1792 << pname_string << "]" 1793 " (int value:[" 1794 << int_value << "])" << tcu::TestLog::EndMessage; 1795 1796 m_has_test_passed = false; 1797 } 1798 } /* for (all pnames) */ 1799 1800 if (m_has_test_passed) 1801 { 1802 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1803 } 1804 else 1805 { 1806 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1807 } 1808 1809 return STOP; 1810 } 1811 1812 /** Constructor. 1813 * 1814 * @param context Rendering context. 1815 * 1816 **/ 1817 APITest2::APITest2(deqp::Context& context) 1818 : TestCase(context, "name_getters", "Verifies glGetActiveSubroutineName() and glGetActiveSubroutineUniformName() " 1819 "functions work correctly.") 1820 , m_buffer(DE_NULL) 1821 , m_has_test_passed(true) 1822 , m_po_id(0) 1823 , m_subroutine_name1("subroutine1") 1824 , m_subroutine_name2("subroutine2") 1825 , m_subroutine_uniform_name("data_provider") 1826 , m_vs_id(0) 1827 { 1828 /* Left blank intentionally */ 1829 } 1830 1831 /** Destroys all ES objects that may have been created during test initialization, 1832 * as well as releases any buffers that may have been allocated during the process. 1833 */ 1834 void APITest2::deinit() 1835 { 1836 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1837 1838 if (m_buffer != DE_NULL) 1839 { 1840 delete[] m_buffer; 1841 1842 m_buffer = DE_NULL; 1843 } 1844 1845 if (m_po_id != 0) 1846 { 1847 gl.deleteProgram(m_po_id); 1848 1849 m_po_id = 0; 1850 } 1851 1852 if (m_vs_id != 0) 1853 { 1854 gl.deleteShader(m_vs_id); 1855 1856 m_vs_id = 0; 1857 } 1858 } 1859 1860 /** Returns body of a vertex shader that should be used for the test. 1861 * 1862 * @return As per description. 1863 **/ 1864 std::string APITest2::getVertexShaderBody() 1865 { 1866 return "#version 400\n" 1867 "\n" 1868 "#extension GL_ARB_shader_subroutine : require\n" 1869 "\n" 1870 "subroutine int ExampleSubroutineType(int example_argument);\n" 1871 "\n" 1872 "subroutine(ExampleSubroutineType) int subroutine1(int example_argument)\n" 1873 "{\n" 1874 " return 1;\n" 1875 "}\n" 1876 "\n" 1877 "subroutine(ExampleSubroutineType) int subroutine2(int example_argument)\n" 1878 "{\n" 1879 " return 2;\n" 1880 "}\n" 1881 "\n" 1882 "subroutine uniform ExampleSubroutineType data_provider;\n" 1883 "\n" 1884 "void main()\n" 1885 "{\n" 1886 " gl_Position = vec4(float(data_provider(0)), vec3(1) );\n" 1887 "}\n"; 1888 } 1889 1890 /** Initializes all ES objects required to run the test. */ 1891 void APITest2::initTest() 1892 { 1893 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1894 1895 /* Generate program & shader objects */ 1896 m_po_id = gl.createProgram(); 1897 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 1898 1899 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() or glCreateShader() call(s) failed."); 1900 1901 /* Attach the shader to the program object */ 1902 gl.attachShader(m_po_id, m_vs_id); 1903 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 1904 1905 /* Compile the shader */ 1906 glw::GLint compile_status = GL_FALSE; 1907 std::string vs_body = getVertexShaderBody(); 1908 const char* vs_body_raw_ptr = vs_body.c_str(); 1909 1910 gl.shaderSource(m_vs_id, 1 /* count */, &vs_body_raw_ptr, DE_NULL /* length */); 1911 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 1912 1913 gl.compileShader(m_vs_id); 1914 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); 1915 1916 gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status); 1917 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 1918 1919 if (compile_status != GL_TRUE) 1920 { 1921 TCU_FAIL("Shader compilation failed."); 1922 } 1923 1924 /* Try to link the program object */ 1925 glw::GLint link_status = GL_FALSE; 1926 1927 gl.linkProgram(m_po_id); 1928 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); 1929 1930 gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status); 1931 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 1932 1933 if (link_status != GL_TRUE) 1934 { 1935 TCU_FAIL("Program linking failed."); 1936 } 1937 1938 /* Perform a few sanity checks */ 1939 glw::GLint n_active_subroutines = 0; 1940 glw::GLint n_active_subroutine_uniforms = 0; 1941 1942 gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines); 1943 gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); 1944 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramStageiv() call failed."); 1945 1946 if (n_active_subroutines != 2 /* subroutines declared in vertex shader */) 1947 { 1948 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid amount of active subroutines reported; expected: 2," 1949 " reported:" 1950 << n_active_subroutines << tcu::TestLog::EndMessage; 1951 1952 TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINES property value."); 1953 } 1954 1955 if (n_active_subroutine_uniforms != 1) 1956 { 1957 m_testCtx.getLog() << tcu::TestLog::Message 1958 << "Invalid amount of active subroutine uniforms reported: expected: 1," 1959 " reported: " 1960 << n_active_subroutine_uniforms << tcu::TestLog::EndMessage; 1961 1962 TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINE_UNIFORMS property value."); 1963 } 1964 } 1965 1966 /** Executes test iteration. 1967 * 1968 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 1969 */ 1970 tcu::TestNode::IterateResult APITest2::iterate() 1971 { 1972 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 1973 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 1974 { 1975 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 1976 } 1977 1978 /* Initialize a test program object */ 1979 initTest(); 1980 1981 /* Verify glGetActiveSubroutineName() works correctly */ 1982 verifyGLGetActiveSubroutineNameFunctionality(); 1983 1984 /* Verify glGetActiveSubroutineUniformName() works correctly */ 1985 verifyGLGetActiveSubroutineUniformNameFunctionality(); 1986 1987 /* Done */ 1988 if (m_has_test_passed) 1989 { 1990 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1991 } 1992 else 1993 { 1994 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1995 } 1996 1997 return STOP; 1998 } 1999 2000 /** Verifies glGetActiveSubroutineName() behaves as per GL_ARB_shader_subroutine 2001 * specification. 2002 **/ 2003 void APITest2::verifyGLGetActiveSubroutineNameFunctionality() 2004 { 2005 GLsizei expected_length1 = (GLsizei)strlen(m_subroutine_name1) + 1; 2006 GLsizei expected_length2 = (GLsizei)strlen(m_subroutine_name1) + 1; 2007 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2008 GLsizei reported_length = 0; 2009 2010 gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, 0, /* index */ 2011 0, /* bufsize */ 2012 DE_NULL, /* length */ 2013 DE_NULL); /* name */ 2014 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed."); 2015 2016 gl.getProgramInterfaceiv(m_po_id, GL_VERTEX_SUBROUTINE, GL_MAX_NAME_LENGTH, &reported_length); 2017 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed."); 2018 2019 if ((reported_length != expected_length1) && (reported_length != expected_length2)) 2020 { 2021 m_testCtx.getLog() << tcu::TestLog::Message 2022 << "Invalid active subroutine name length reported:" << reported_length 2023 << ", instead of: " << expected_length1 << " or " << expected_length2 2024 << tcu::TestLog::EndMessage; 2025 2026 TCU_FAIL("Incorrect length of active subroutine name"); 2027 } 2028 2029 m_buffer = new glw::GLchar[reported_length]; 2030 2031 memset(m_buffer, 0, reported_length); 2032 2033 gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, 0, reported_length, DE_NULL, /* length */ 2034 m_buffer); 2035 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed."); 2036 2037 if (strcmp(m_buffer, m_subroutine_name1) != 0 && strcmp(m_buffer, m_subroutine_name2) != 0) 2038 { 2039 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid active subroutine name reported:[" << m_buffer 2040 << "]" 2041 " instead of:[" 2042 << m_subroutine_name1 << "]" 2043 " or:[" 2044 << m_subroutine_name2 << "]." << tcu::TestLog::EndMessage; 2045 2046 TCU_FAIL("Invalid active subroutine name reported."); 2047 } 2048 2049 delete[] m_buffer; 2050 m_buffer = DE_NULL; 2051 } 2052 2053 /** Verifies glGetActiveSubroutineUniformName() behaves as per GL_ARB_shader_subroutine 2054 * specification. 2055 **/ 2056 void APITest2::verifyGLGetActiveSubroutineUniformNameFunctionality() 2057 { 2058 GLsizei expected_length = (GLsizei)strlen(m_subroutine_uniform_name); 2059 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2060 GLsizei reported_length = 0; 2061 2062 gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, /* index */ 2063 0, /* bufsize */ 2064 DE_NULL, /* length */ 2065 DE_NULL); /* name */ 2066 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineUniformName() call failed."); 2067 2068 gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, /* index */ 2069 0, /* bufsize */ 2070 &reported_length, DE_NULL); /* name */ 2071 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineUniformName() call failed."); 2072 2073 // reported_length is the actual number of characters written into <name> 2074 // If <bufSize> is 0, reported_length should be 0 2075 if (reported_length != 0) 2076 { 2077 m_testCtx.getLog() << tcu::TestLog::Message 2078 << "Invalid active subroutine uniform name length reported:" << reported_length 2079 << ", instead of: " << 0 << tcu::TestLog::EndMessage; 2080 2081 TCU_FAIL("Incorrect length of active subroutine uniform name"); 2082 } 2083 2084 m_buffer = new glw::GLchar[expected_length + 1]; 2085 2086 memset(m_buffer, 0, expected_length + 1); 2087 2088 gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, expected_length + 1, &reported_length, m_buffer); 2089 GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformName() call failed."); 2090 2091 if (reported_length != expected_length) 2092 { 2093 m_testCtx.getLog() << tcu::TestLog::Message 2094 << "Invalid active subroutine uniform name length reported:" << reported_length 2095 << ", instead of: " << expected_length << tcu::TestLog::EndMessage; 2096 2097 TCU_FAIL("Incorrect length of active subroutine uniform name"); 2098 } 2099 2100 if (strcmp(m_buffer, m_subroutine_uniform_name) != 0) 2101 { 2102 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid active subroutine uniform name reported:[" << m_buffer 2103 << "]" 2104 " instead of:[" 2105 << m_subroutine_uniform_name << "]" << tcu::TestLog::EndMessage; 2106 2107 TCU_FAIL("Invalid active subroutine uniform name reported."); 2108 } 2109 2110 delete[] m_buffer; 2111 m_buffer = DE_NULL; 2112 } 2113 2114 /** Constructor. 2115 * 2116 * @param context Rendering context. 2117 * 2118 **/ 2119 FunctionalTest1_2::FunctionalTest1_2(deqp::Context& context) 2120 : TestCase(context, "two_subroutines_single_subroutine_uniform", 2121 "Verifies the subroutines work correctly in a vertex shader for" 2122 " bool/float/int/uint/double/*vec*/*mat* argument and return types") 2123 , m_has_test_passed(true) 2124 , m_po_id(0) 2125 , m_po_getter0_subroutine_index(GL_INVALID_INDEX) 2126 , m_po_getter1_subroutine_index(GL_INVALID_INDEX) 2127 , m_po_subroutine_uniform_index(-1) 2128 , m_xfb_bo_id(0) 2129 , m_vao_id(0) 2130 , m_vs_id(0) 2131 { 2132 /* Left blank intentionally */ 2133 } 2134 2135 /** Destroys all ES objects that may have been created during test initialization, 2136 * as well as releases any buffers that may have been allocated during the process. 2137 */ 2138 void FunctionalTest1_2::deinit() 2139 { 2140 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2141 2142 deinitTestIteration(); 2143 2144 if (m_xfb_bo_id != 0) 2145 { 2146 gl.deleteBuffers(1, &m_xfb_bo_id); 2147 2148 m_xfb_bo_id = 0; 2149 } 2150 2151 if (m_vao_id != 0) 2152 { 2153 gl.deleteVertexArrays(1, &m_vao_id); 2154 2155 m_vao_id = 0; 2156 } 2157 } 2158 2159 /** Deinitializes GL objects that are iteration-specific */ 2160 void FunctionalTest1_2::deinitTestIteration() 2161 { 2162 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2163 2164 if (m_po_id != 0) 2165 { 2166 gl.deleteProgram(m_po_id); 2167 2168 m_po_id = 0; 2169 } 2170 2171 if (m_vs_id != 0) 2172 { 2173 gl.deleteShader(m_vs_id); 2174 2175 m_vs_id = 0; 2176 } 2177 } 2178 2179 /** Executes a single test iteration using user-specified test case propertiesz. 2180 * 2181 * @param test-case Test case descriptor. 2182 * 2183 * @return true if the test iteration passed, false otherwise. 2184 **/ 2185 bool FunctionalTest1_2::executeTestIteration(const _test_case& test_case) 2186 { 2187 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2188 bool result = true; 2189 2190 /* Build the test program */ 2191 std::string empty_body; 2192 std::string vs_body = getVertexShaderBody(test_case.variable_type, test_case.array_size); 2193 const glw::GLchar* xfb_varyings[] = { "result" }; 2194 const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]); 2195 2196 if (!Utils::buildProgram(gl, vs_body, empty_body, empty_body, empty_body, empty_body, xfb_varyings, n_xfb_varyings, 2197 &m_vs_id, NULL, /* out_tc_id */ 2198 NULL, /* out_te_id */ 2199 NULL, /* out_gs_id */ 2200 NULL, &m_po_id)) 2201 { 2202 TCU_FAIL("Test program failed to build."); 2203 } 2204 2205 /* Retrieve subroutine locations */ 2206 m_po_getter0_subroutine_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "getter0"); 2207 m_po_getter1_subroutine_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "getter1"); 2208 2209 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); 2210 2211 if (m_po_getter0_subroutine_index == GL_INVALID_INDEX || m_po_getter1_subroutine_index == GL_INVALID_INDEX) 2212 { 2213 TCU_FAIL("At least one subroutine is considered inactive which is invalid."); 2214 } 2215 2216 /* Retrieve subroutine uniform location */ 2217 m_po_subroutine_uniform_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "colorGetterUniform"); 2218 2219 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call failed."); 2220 2221 if (m_po_subroutine_uniform_index == -1) 2222 { 2223 TCU_FAIL("Subroutine uniform is considered inactive which is invalid."); 2224 } 2225 2226 /* Set up XFB BO storage */ 2227 const Utils::_variable_type base_variable_type = Utils::getBaseVariableType(test_case.variable_type); 2228 unsigned int iteration_xfb_bo_size = Utils::getComponentSizeForVariableType(base_variable_type) * 2229 Utils::getNumberOfComponentsForVariableType(test_case.variable_type); 2230 unsigned int total_xfb_bo_size = 0; 2231 2232 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) 2233 { 2234 /* Boolean varyings are not supported by OpenGL. Instead, we use ints to output 2235 * boolean values. */ 2236 iteration_xfb_bo_size = static_cast<unsigned int>(iteration_xfb_bo_size * sizeof(int)); 2237 } 2238 2239 total_xfb_bo_size = iteration_xfb_bo_size * 2 /* subroutines we will be testing */; 2240 2241 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, total_xfb_bo_size, DE_NULL /* data */, GL_STATIC_DRAW); 2242 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 2243 2244 /* Activate test program object */ 2245 gl.useProgram(m_po_id); 2246 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 2247 2248 /* Run two iterations. Each iteration should invoke different subroutine. */ 2249 const glw::GLuint subroutine_indices[] = { m_po_getter0_subroutine_index, m_po_getter1_subroutine_index }; 2250 const unsigned int n_subroutine_indices = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); 2251 2252 for (unsigned int n_subroutine_index = 0; n_subroutine_index < n_subroutine_indices; ++n_subroutine_index) 2253 { 2254 /* Configure which subroutine should be used for the draw call */ 2255 glw::GLuint current_subroutine_index = subroutine_indices[n_subroutine_index]; 2256 2257 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 1 /* count */, ¤t_subroutine_index); 2258 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed."); 2259 2260 /* Update XFB binding so that we do not overwrite data XFBed in previous iterations */ 2261 gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */ 2262 m_xfb_bo_id, iteration_xfb_bo_size * n_subroutine_index, iteration_xfb_bo_size); 2263 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange() call failed."); 2264 2265 /* Draw a single point */ 2266 gl.beginTransformFeedback(GL_POINTS); 2267 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); 2268 { 2269 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 2270 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 2271 } 2272 gl.endTransformFeedback(); 2273 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); 2274 } /* for (all subroutine indices) */ 2275 2276 /* Map the BO storage into process space */ 2277 const void* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 2278 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); 2279 2280 result &= verifyXFBData(xfb_data_ptr, test_case.variable_type); 2281 2282 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 2283 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffeR() call failed."); 2284 2285 return result; 2286 } 2287 2288 /** Retrieves body of a vertex shader that should be used to verify 2289 * subroutine support, given user-specified test iteration properties. 2290 * 2291 * @param variable_type GLSL type that should be used for argument and 2292 * return type definition in a subroutine. This setting 2293 * also affects type of the only output variable in the shader. 2294 * @param array_size 1 if non-arrayed arguments/return types should be tested; 2295 * 2 if arrayed arguments/return types should be tested. 2296 * 2297 * @return Requested string. 2298 **/ 2299 std::string FunctionalTest1_2::getVertexShaderBody(const Utils::_variable_type& variable_type, unsigned int array_size) 2300 { 2301 Utils::_variable_type base_variable_type = Utils::getBaseVariableType(variable_type); 2302 unsigned int n_variable_type_components = Utils::getNumberOfComponentsForVariableType(variable_type); 2303 std::stringstream result_sstream; 2304 std::string variable_type_glsl = Utils::getVariableTypeGLSLString(variable_type); 2305 std::stringstream variable_type_glsl_array_sstream; 2306 std::stringstream variable_type_glsl_arrayed_sstream; 2307 2308 variable_type_glsl_arrayed_sstream << variable_type_glsl; 2309 2310 if (array_size > 1) 2311 { 2312 variable_type_glsl_array_sstream << "[" << array_size << "]"; 2313 variable_type_glsl_arrayed_sstream << variable_type_glsl_array_sstream.str(); 2314 } 2315 2316 /* Form pre-amble */ 2317 result_sstream << "#version 400\n" 2318 "\n" 2319 "#extension GL_ARB_shader_subroutine : require\n"; 2320 2321 if (variable_type == Utils::VARIABLE_TYPE_DOUBLE) 2322 { 2323 result_sstream << "#extension GL_ARB_gpu_shader_fp64 : require\n"; 2324 } 2325 2326 /* Form subroutine type declaration */ 2327 result_sstream << "\n" 2328 "subroutine " 2329 << variable_type_glsl_arrayed_sstream.str() << " colorGetter(in " << variable_type_glsl 2330 << " in_value" << variable_type_glsl_array_sstream.str() << ");\n" 2331 "\n"; 2332 2333 /* Declare getter functions */ 2334 for (int n_getter = 0; n_getter < 2; ++n_getter) 2335 { 2336 result_sstream << "subroutine(colorGetter) " << variable_type_glsl_arrayed_sstream.str() << " getter" 2337 << n_getter << "(in " << variable_type_glsl << " in_value" 2338 << variable_type_glsl_array_sstream.str() << ")\n" 2339 "{\n"; 2340 2341 if (array_size > 1) 2342 { 2343 result_sstream << variable_type_glsl << " temp" << variable_type_glsl_array_sstream.str() << ";\n"; 2344 } 2345 2346 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) 2347 { 2348 if (array_size > 1) 2349 { 2350 for (unsigned int array_index = 0; array_index < array_size; ++array_index) 2351 { 2352 result_sstream << " temp[" << array_index << "]" 2353 " = " 2354 << ((n_getter == 0) ? ((variable_type_glsl == "bool") ? "!" : "not") : "") 2355 << "(in_value[" << array_index << "]);\n"; 2356 } 2357 2358 result_sstream << " return temp;\n"; 2359 } 2360 else 2361 { 2362 result_sstream << " return " 2363 << ((n_getter == 0) ? ((variable_type_glsl == "bool") ? "!" : "not") : "") 2364 << "(in_value);\n"; 2365 } 2366 } /* if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) */ 2367 else 2368 { 2369 if (array_size > 1) 2370 { 2371 for (unsigned int array_index = 0; array_index < array_size; ++array_index) 2372 { 2373 result_sstream << " temp[" << array_index << "]" 2374 " = in_value[" 2375 << array_index << "] + " << (n_getter + 1) << ";\n"; 2376 } 2377 2378 result_sstream << " return temp;\n"; 2379 } 2380 else 2381 { 2382 result_sstream << " return (in_value + " << (n_getter + 1) << ");\n"; 2383 } 2384 } 2385 2386 result_sstream << "}\n"; 2387 } /* for (both getter functions) */ 2388 2389 /* Declare subroutine uniform */ 2390 result_sstream << "subroutine uniform colorGetter colorGetterUniform;\n" 2391 "\n"; 2392 2393 /* Declare output variable */ 2394 result_sstream << "out "; 2395 2396 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) 2397 { 2398 Utils::_variable_type result_as_int_variable_type = 2399 Utils::getVariableTypeFromProperties(Utils::VARIABLE_TYPE_INT, n_variable_type_components); 2400 std::string variable_type_glsl_as_int = Utils::getVariableTypeGLSLString(result_as_int_variable_type); 2401 2402 result_sstream << variable_type_glsl_as_int; 2403 } 2404 else 2405 { 2406 result_sstream << variable_type_glsl; 2407 } 2408 2409 result_sstream << " result;\n" 2410 "\n"; 2411 2412 /* Declare main(): prepare input argument for the subroutine function */ 2413 result_sstream << "void main()\n" 2414 "{\n" 2415 " " 2416 << variable_type_glsl << " temp"; 2417 2418 if (array_size > 1) 2419 { 2420 result_sstream << "[" << array_size << "]"; 2421 }; 2422 2423 result_sstream << ";\n"; 2424 2425 for (unsigned int array_index = 0; array_index < array_size; ++array_index) 2426 { 2427 result_sstream << " temp"; 2428 2429 if (array_size > 1) 2430 { 2431 result_sstream << "[" << array_index << "]"; 2432 } 2433 2434 result_sstream << " = " << variable_type_glsl << "("; 2435 2436 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) 2437 { 2438 result_sstream << "true"; 2439 } 2440 else 2441 { 2442 for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component) 2443 { 2444 result_sstream << "3"; 2445 2446 if (n_component != (n_variable_type_components - 1)) 2447 { 2448 result_sstream << ", "; 2449 } 2450 } /* for (all components) */ 2451 } 2452 2453 result_sstream << ");\n"; 2454 } /* for (all array indices) */ 2455 2456 /* Declare main(): call the subroutine. Verify the input and write the result 2457 * to the output variable. 2458 **/ 2459 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) 2460 { 2461 Utils::_variable_type result_as_int_variable_type = 2462 Utils::getVariableTypeFromProperties(Utils::VARIABLE_TYPE_INT, n_variable_type_components); 2463 std::string variable_type_glsl_as_int = Utils::getVariableTypeGLSLString(result_as_int_variable_type); 2464 2465 result_sstream << variable_type_glsl_arrayed_sstream.str() << " subroutine_result = colorGetterUniform(temp);\n" 2466 "result = "; 2467 2468 for (unsigned int array_index = 0; array_index < array_size; ++array_index) 2469 { 2470 if (variable_type_glsl == "bool") 2471 result_sstream << "bool(subroutine_result"; 2472 else 2473 result_sstream << "all(subroutine_result"; 2474 2475 if (array_size > 1) 2476 { 2477 result_sstream << "[" << array_index << "]"; 2478 } 2479 2480 result_sstream << ")"; 2481 2482 if (array_index != (array_size - 1)) 2483 { 2484 result_sstream << "&& "; 2485 } 2486 } 2487 2488 result_sstream << " == true ? " << variable_type_glsl_as_int << "(1) : " << variable_type_glsl_as_int << "(0);"; 2489 } 2490 else 2491 { 2492 if (array_size > 1) 2493 { 2494 DE_ASSERT(array_size == 2); 2495 2496 result_sstream << variable_type_glsl << " subroutine_result" << variable_type_glsl_array_sstream.str() 2497 << " = colorGetterUniform(temp);\n" 2498 "\n" 2499 "if (subroutine_result[0] == subroutine_result[1]) result = subroutine_result[0];\n" 2500 "else\n" 2501 "result = " 2502 << variable_type_glsl << "(-1);\n"; 2503 } 2504 else 2505 { 2506 result_sstream << "result = colorGetterUniform(temp);\n"; 2507 } 2508 } 2509 2510 /* All done */ 2511 result_sstream << "}\n"; 2512 2513 return result_sstream.str(); 2514 } 2515 2516 /** Initializes all GL objects required to run the test. */ 2517 void FunctionalTest1_2::initTest() 2518 { 2519 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2520 2521 /* Generate buffer object to hold result XFB data */ 2522 gl.genBuffers(1, &m_xfb_bo_id); 2523 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 2524 2525 /* Set up XFB BO bindings */ 2526 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id); 2527 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); 2528 2529 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id); 2530 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); 2531 2532 /* Generate VAO to use for the draw calls */ 2533 gl.genVertexArrays(1, &m_vao_id); 2534 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 2535 2536 gl.bindVertexArray(m_vao_id); 2537 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 2538 } 2539 2540 /** Executes test iteration. 2541 * 2542 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 2543 */ 2544 tcu::TestNode::IterateResult FunctionalTest1_2::iterate() 2545 { 2546 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 2547 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 2548 { 2549 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 2550 } 2551 2552 /* Initialize a test program object */ 2553 initTest(); 2554 2555 /* Construct test case descriptors: first, iIerate over all 2556 * variable types we want to cover */ 2557 const Utils::_variable_type variable_types[] = { 2558 Utils::VARIABLE_TYPE_BOOL, Utils::VARIABLE_TYPE_BVEC2, Utils::VARIABLE_TYPE_BVEC3, 2559 Utils::VARIABLE_TYPE_BVEC4, Utils::VARIABLE_TYPE_DOUBLE, Utils::VARIABLE_TYPE_FLOAT, 2560 Utils::VARIABLE_TYPE_INT, Utils::VARIABLE_TYPE_IVEC2, Utils::VARIABLE_TYPE_IVEC3, 2561 Utils::VARIABLE_TYPE_IVEC4, Utils::VARIABLE_TYPE_MAT2, Utils::VARIABLE_TYPE_MAT2X3, 2562 Utils::VARIABLE_TYPE_MAT2X4, Utils::VARIABLE_TYPE_MAT3, Utils::VARIABLE_TYPE_MAT3X2, 2563 Utils::VARIABLE_TYPE_MAT3X4, Utils::VARIABLE_TYPE_MAT4, Utils::VARIABLE_TYPE_MAT4X2, 2564 Utils::VARIABLE_TYPE_MAT4X3, Utils::VARIABLE_TYPE_UINT, Utils::VARIABLE_TYPE_UVEC2, 2565 Utils::VARIABLE_TYPE_UVEC3, Utils::VARIABLE_TYPE_UVEC4, Utils::VARIABLE_TYPE_VEC2, 2566 Utils::VARIABLE_TYPE_VEC3, Utils::VARIABLE_TYPE_VEC4 2567 }; 2568 const unsigned int n_variable_types = sizeof(variable_types) / sizeof(variable_types[0]); 2569 2570 for (unsigned int n_variable_type = 0; n_variable_type < n_variable_types; ++n_variable_type) 2571 { 2572 Utils::_variable_type current_variable_type = variable_types[n_variable_type]; 2573 2574 /* We need to test both arrayed and non-arrayed arguments */ 2575 for (unsigned int array_size = 1; array_size < 3; ++array_size) 2576 { 2577 /* Exclude double variables if the relevant extension is unavailable */ 2578 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_gpu_shader_fp64") && 2579 current_variable_type == Utils::VARIABLE_TYPE_DOUBLE) 2580 { 2581 continue; 2582 } 2583 2584 /* Form the descriptor */ 2585 _test_case test_case; 2586 2587 test_case.array_size = array_size; 2588 test_case.variable_type = current_variable_type; 2589 2590 /* Store the test case descriptor */ 2591 m_test_cases.push_back(test_case); 2592 } /* for (both arrayed and non-arrayed arguments) */ 2593 } /* for (all variable types) */ 2594 2595 /* Iterate over all test cases and execute the test */ 2596 for (_test_cases_const_iterator test_case_iterator = m_test_cases.begin(); test_case_iterator != m_test_cases.end(); 2597 ++test_case_iterator) 2598 { 2599 const _test_case& test_case = *test_case_iterator; 2600 2601 m_has_test_passed &= executeTestIteration(test_case); 2602 2603 /* Release GL objects that were created during the execution */ 2604 deinitTestIteration(); 2605 } /* for (all test cases) */ 2606 2607 /* Done */ 2608 if (m_has_test_passed) 2609 { 2610 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2611 } 2612 else 2613 { 2614 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2615 } 2616 2617 return STOP; 2618 } 2619 2620 /** Verifies data that has been XFBed out by the vertex shader. 2621 * 2622 * @param xfb_data Buffer holding the data. 2623 * @param variable_type GLSL type used for the test iteration 2624 * that generated the data at @param xfb_data. 2625 * 2626 * @return true if the data was found to be valid, false if it 2627 * was detected to be incorrect. 2628 **/ 2629 bool FunctionalTest1_2::verifyXFBData(const void* xfb_data, const Utils::_variable_type& variable_type) 2630 { 2631 const Utils::_variable_type base_variable_type = Utils::getBaseVariableType(variable_type); 2632 const float epsilon = 1e-5f; 2633 const unsigned int n_variable_type_components = Utils::getNumberOfComponentsForVariableType(variable_type); 2634 bool result = true; 2635 const unsigned char* traveller_ptr = (const unsigned char*)xfb_data; 2636 2637 /* Boolean arguments/return types are tested with a slightly different shader so we 2638 * need to test them in a separate code-path. 2639 */ 2640 if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) 2641 { 2642 /* 0 should be returned when getter0 is used, 1 otherwise */ 2643 const unsigned int ref_values[] = { 0, 1 }; 2644 const unsigned int n_ref_values = sizeof(ref_values) / sizeof(ref_values[0]); 2645 2646 for (unsigned int n_ref_value = 0; n_ref_value < n_ref_values; ++n_ref_value) 2647 { 2648 const unsigned int ref_value = ref_values[n_ref_value]; 2649 2650 for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component) 2651 { 2652 int* result_value_ptr = (int*)(traveller_ptr); 2653 2654 if (*result_value_ptr != (int)ref_value) 2655 { 2656 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " 2657 "[" 2658 << Utils::getVariableTypeGLSLString(variable_type) << "]" 2659 << " argument/return types (" 2660 "expected:[" 2661 << ref_value << "], found:[" << *result_value_ptr << "])" 2662 << tcu::TestLog::EndMessage; 2663 2664 result = false; 2665 break; 2666 } 2667 2668 traveller_ptr += sizeof(int); 2669 } /* for (all components) */ 2670 } /* for (all reference values) */ 2671 } /* if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) */ 2672 else 2673 { 2674 /* 4 should be returned when getter0 is used, 5 otherwise */ 2675 const unsigned int ref_values[] = { 4, 5 }; 2676 const unsigned int n_ref_values = sizeof(ref_values) / sizeof(ref_values[0]); 2677 2678 for (unsigned int n_ref_value = 0; n_ref_value < n_ref_values; ++n_ref_value) 2679 { 2680 const unsigned int ref_value = ref_values[n_ref_value]; 2681 2682 DE_ASSERT( 2683 base_variable_type == Utils::VARIABLE_TYPE_DOUBLE || base_variable_type == Utils::VARIABLE_TYPE_FLOAT || 2684 base_variable_type == Utils::VARIABLE_TYPE_INT || base_variable_type == Utils::VARIABLE_TYPE_UINT); 2685 2686 for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component) 2687 { 2688 const double* double_value_ptr = (double*)traveller_ptr; 2689 const float* float_value_ptr = (float*)traveller_ptr; 2690 const int* int_value_ptr = (int*)traveller_ptr; 2691 2692 switch (base_variable_type) 2693 { 2694 case Utils::VARIABLE_TYPE_DOUBLE: 2695 { 2696 if (de::abs(*double_value_ptr - (double)ref_value) > epsilon) 2697 { 2698 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " 2699 "[" 2700 << Utils::getVariableTypeGLSLString(variable_type) << "]" 2701 << " argument/return types (" 2702 "expected:[" 2703 << ref_value << "], found:[" << *double_value_ptr << "])" 2704 << tcu::TestLog::EndMessage; 2705 2706 result = false; 2707 } 2708 2709 traveller_ptr += sizeof(double); 2710 break; 2711 } 2712 2713 case Utils::VARIABLE_TYPE_FLOAT: 2714 { 2715 if (de::abs(*float_value_ptr - (float)ref_value) > epsilon) 2716 { 2717 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " 2718 "[" 2719 << Utils::getVariableTypeGLSLString(variable_type) << "]" 2720 << " argument/return types (" 2721 "expected:[" 2722 << ref_value << "], found:[" << *float_value_ptr << "])" 2723 << tcu::TestLog::EndMessage; 2724 2725 result = false; 2726 } 2727 2728 traveller_ptr += sizeof(float); 2729 break; 2730 } 2731 2732 case Utils::VARIABLE_TYPE_INT: 2733 case Utils::VARIABLE_TYPE_UINT: 2734 { 2735 if (*int_value_ptr != (int)ref_value) 2736 { 2737 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " 2738 "[" 2739 << Utils::getVariableTypeGLSLString(variable_type) << "]" 2740 << " argument/return types (" 2741 "expected:[" 2742 << ref_value << "], found:[" << *int_value_ptr << "])" 2743 << tcu::TestLog::EndMessage; 2744 2745 result = false; 2746 } 2747 2748 traveller_ptr += sizeof(int); 2749 break; 2750 } 2751 2752 default: 2753 break; 2754 } /* switch (base_variable_type) */ 2755 } /* for (all components) */ 2756 } /* for (all reference values) */ 2757 } 2758 2759 return result; 2760 } 2761 2762 /** Constructor 2763 * 2764 * @param context CTS context 2765 **/ 2766 FunctionalTest3_4::FunctionalTest3_4(deqp::Context& context) 2767 : TestCase(context, "four_subroutines_with_two_uniforms", "Verify Get* API and draw calls") 2768 , m_n_active_subroutine_uniforms(0) 2769 , m_n_active_subroutine_uniform_locations(0) 2770 , m_n_active_subroutines(0) 2771 , m_n_active_subroutine_uniform_name_length(0) 2772 , m_n_active_subroutine_name_length(0) 2773 , m_n_active_subroutine_uniform_size(0) 2774 { 2775 /* Nothing to be done here */ 2776 } 2777 2778 /** Execute test 2779 * 2780 * @return tcu::TestNode::STOP 2781 **/ 2782 tcu::TestNode::IterateResult FunctionalTest3_4::iterate() 2783 { 2784 static const glw::GLchar* vertex_shader_code = 2785 "#version 400 core\n" 2786 "#extension GL_ARB_shader_subroutine : require\n" 2787 "\n" 2788 "precision highp float;\n" 2789 "\n" 2790 "// Sub routine type declaration\n" 2791 "subroutine vec4 routine_type(in vec4 iparam);\n" 2792 "\n" 2793 "// Sub routine definitions\n" 2794 "subroutine(routine_type) vec4 inverse_order(in vec4 iparam)\n" 2795 "{\n" 2796 " return iparam.wzyx;\n" 2797 "}\n" 2798 "\n" 2799 "subroutine(routine_type) vec4 negate(in vec4 iparam)\n" 2800 "{\n" 2801 " return -iparam;\n" 2802 "}\n" 2803 "\n" 2804 "subroutine(routine_type) vec4 inverse(in vec4 iparam)\n" 2805 "{\n" 2806 " return 1 / iparam;\n" 2807 "}\n" 2808 "\n" 2809 "subroutine(routine_type) vec4 square(in vec4 iparam)\n" 2810 "{\n" 2811 " return iparam * iparam;\n" 2812 "}\n" 2813 "\n" 2814 "// Sub routine uniforms\n" 2815 "subroutine uniform routine_type first_routine;\n" 2816 "subroutine uniform routine_type second_routine;\n" 2817 "\n" 2818 "// Input data\n" 2819 "uniform vec4 input_data;\n" 2820 "\n" 2821 "// Output\n" 2822 "out vec4 out_input_data;\n" 2823 "out vec4 out_result_from_first_routine;\n" 2824 "out vec4 out_result_from_second_routine;\n" 2825 "out vec4 out_result_from_combined_routines;\n" 2826 "out vec4 out_result_from_routines_combined_in_reveresed_order;\n" 2827 "\n" 2828 "void main()\n" 2829 "{\n" 2830 " out_input_data = input_data;\n" 2831 " out_result_from_first_routine = first_routine(input_data);\n" 2832 " out_result_from_second_routine = second_routine(input_data);\n" 2833 " out_result_from_combined_routines = second_routine(first_routine(input_data));\n" 2834 " out_result_from_routines_combined_in_reveresed_order = first_routine(second_routine(input_data));\n" 2835 "}\n" 2836 "\n"; 2837 2838 static const GLchar* varying_names[] = { 2839 "out_input_data", 2840 "out_result_from_first_routine", 2841 "out_result_from_second_routine", 2842 "out_result_from_combined_routines", 2843 "out_result_from_routines_combined_in_reveresed_order", 2844 }; 2845 2846 static const GLchar* subroutine_uniform_names[] = { "first_routine", "second_routine" }; 2847 2848 static const GLchar* subroutine_names[] = { "inverse_order", "negate", "inverse", "square" }; 2849 2850 static const GLuint n_varyings = sizeof(varying_names) / sizeof(varying_names[0]); 2851 static const GLuint transform_feedback_buffer_size = n_varyings * sizeof(GLfloat) * 4 /* vec4 */; 2852 2853 static const GLuint inverse_order_routine_index = 0; 2854 static const GLuint negate_routine_index = 1; 2855 static const GLuint inverse_routine_index = 2; 2856 static const GLuint square_routine_index = 3; 2857 2858 /* Test data */ 2859 static const Utils::vec4<GLfloat> inverse_order_negate_data[5] = { 2860 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), 2861 Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), 2862 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), 2863 }; 2864 2865 static const Utils::vec4<GLfloat> inverse_order_inverse_data[5] = { 2866 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), 2867 Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), 2868 Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), 2869 }; 2870 2871 static const Utils::vec4<GLfloat> inverse_order_square_data[5] = { 2872 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), 2873 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), 2874 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), 2875 }; 2876 2877 static const Utils::vec4<GLfloat> negate_inverse_data[5] = { 2878 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), 2879 Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), 2880 Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), 2881 }; 2882 2883 static const Utils::vec4<GLfloat> negate_square_data[5] = { 2884 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), 2885 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), 2886 Utils::vec4<GLfloat>(-4.0f, -1.0f, -1.0f, -4.0f), 2887 }; 2888 2889 static const Utils::vec4<GLfloat> inverse_square_data[5] = { 2890 Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), 2891 Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), Utils::vec4<GLfloat>(0.25f, 1.0f, 1.0f, 0.25f), 2892 Utils::vec4<GLfloat>(0.25f, 1.0f, 1.0f, 0.25f), 2893 }; 2894 2895 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 2896 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 2897 { 2898 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 2899 } 2900 2901 m_n_active_subroutine_uniforms = 2; 2902 m_n_active_subroutine_uniform_locations = 2; 2903 m_n_active_subroutines = 4; 2904 m_n_active_subroutine_uniform_name_length = 0; 2905 m_n_active_subroutine_name_length = 0; 2906 m_n_active_subroutine_uniform_size = 1; 2907 2908 /* GL objects */ 2909 Utils::program program(m_context); 2910 Utils::buffer transform_feedback_buffer(m_context); 2911 Utils::vertexArray vao(m_context); 2912 2913 bool result = true; 2914 2915 /* Calculate max name lengths for subroutines and subroutine uniforms */ 2916 for (GLint i = 0; i < m_n_active_subroutine_uniforms; ++i) 2917 { 2918 const GLsizei length = (GLsizei)strlen(subroutine_uniform_names[i]); 2919 2920 if (length > m_n_active_subroutine_uniform_name_length) 2921 { 2922 m_n_active_subroutine_uniform_name_length = length; 2923 } 2924 } 2925 2926 for (GLint i = 0; i < m_n_active_subroutines; ++i) 2927 { 2928 const GLsizei length = (GLsizei)strlen(subroutine_names[i]); 2929 2930 if (length > m_n_active_subroutine_name_length) 2931 { 2932 m_n_active_subroutine_name_length = length; 2933 } 2934 } 2935 2936 /* Init */ 2937 program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names, 2938 n_varyings); 2939 2940 vao.generate(); 2941 vao.bind(); 2942 2943 transform_feedback_buffer.generate(); 2944 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, 2945 GL_DYNAMIC_COPY); 2946 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); 2947 2948 program.use(); 2949 2950 /* Inspect Get* API */ 2951 if ((false == inspectProgramStageiv(program.m_program_object_id)) || 2952 (false == inspectActiveSubroutineUniformiv(program.m_program_object_id, subroutine_uniform_names)) || 2953 (false == inspectActiveSubroutineUniformName(program.m_program_object_id, subroutine_uniform_names)) || 2954 (false == inspectActiveSubroutineName(program.m_program_object_id, subroutine_names)) || 2955 (false == 2956 inspectSubroutineBinding(program.m_program_object_id, subroutine_names, subroutine_uniform_names, false))) 2957 { 2958 result = false; 2959 } 2960 2961 /* Inspect GetProgram* API */ 2962 if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_program_interface_query")) 2963 { 2964 if ((false == inspectProgramInterfaceiv(program.m_program_object_id)) || 2965 (false == 2966 inspectProgramResourceiv(program.m_program_object_id, subroutine_names, subroutine_uniform_names)) || 2967 (false == 2968 inspectSubroutineBinding(program.m_program_object_id, subroutine_names, subroutine_uniform_names, true))) 2969 { 2970 result = false; 2971 } 2972 } 2973 2974 /* Test shader execution */ 2975 if ((false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], 2976 subroutine_names[negate_routine_index], subroutine_uniform_names, inverse_order_negate_data, 2977 false)) || 2978 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], 2979 subroutine_names[inverse_routine_index], subroutine_uniform_names, 2980 inverse_order_inverse_data, false)) || 2981 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], 2982 subroutine_names[square_routine_index], subroutine_uniform_names, inverse_order_square_data, 2983 false)) || 2984 (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], 2985 subroutine_names[inverse_routine_index], subroutine_uniform_names, negate_inverse_data, 2986 false)) || 2987 (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], 2988 subroutine_names[square_routine_index], subroutine_uniform_names, negate_square_data, 2989 false)) || 2990 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_routine_index], 2991 subroutine_names[square_routine_index], subroutine_uniform_names, inverse_square_data, 2992 false))) 2993 { 2994 result = false; 2995 } 2996 2997 if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_program_interface_query")) 2998 { 2999 if ((false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], 3000 subroutine_names[negate_routine_index], subroutine_uniform_names, 3001 inverse_order_negate_data, true)) || 3002 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], 3003 subroutine_names[inverse_routine_index], subroutine_uniform_names, 3004 inverse_order_inverse_data, true)) || 3005 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], 3006 subroutine_names[square_routine_index], subroutine_uniform_names, 3007 inverse_order_square_data, true)) || 3008 (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], 3009 subroutine_names[inverse_routine_index], subroutine_uniform_names, negate_inverse_data, 3010 true)) || 3011 (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], 3012 subroutine_names[square_routine_index], subroutine_uniform_names, negate_square_data, 3013 true)) || 3014 (false == testDraw(program.m_program_object_id, subroutine_names[inverse_routine_index], 3015 subroutine_names[square_routine_index], subroutine_uniform_names, inverse_square_data, 3016 true))) 3017 { 3018 result = false; 3019 } 3020 } 3021 3022 /* Done */ 3023 if (true == result) 3024 { 3025 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 3026 } 3027 else 3028 { 3029 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 3030 } 3031 3032 return tcu::TestNode::STOP; 3033 } 3034 3035 /** Verify result of getProgramStageiv 3036 * 3037 * @param program_id Program object id 3038 * @param pname <pname> parameter for getProgramStageiv 3039 * @param expected Expected value 3040 * 3041 * @return true if result is equal to expected value, flase otherwise 3042 **/ 3043 bool FunctionalTest3_4::checkProgramStageiv(glw::GLuint program_id, glw::GLenum pname, glw::GLint expected) const 3044 { 3045 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3046 GLint value = 0; 3047 3048 gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, pname, &value); 3049 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); 3050 3051 if (expected != value) 3052 { 3053 m_context.getTestContext().getLog() << tcu::TestLog::Message 3054 << "Error. Invalid result. Function: getProgramStageiv. " 3055 << "pname: " << Utils::pnameToStr(pname) << ". " 3056 << "Result: " << value << ". " 3057 << "Expected: " << expected << "." << tcu::TestLog::EndMessage; 3058 3059 return false; 3060 } 3061 else 3062 { 3063 return true; 3064 } 3065 } 3066 3067 /** Verify result of getProgramResourceiv 3068 * 3069 * @param program_id Program object id 3070 * @param program_interface Program interface 3071 * @param pname <pname> parameter for getProgramStageiv 3072 * @param resource_name Resource name 3073 * @param expected Expected value 3074 * 3075 * @return true if result is equal to expected value, false otherwise 3076 **/ 3077 bool FunctionalTest3_4::checkProgramResourceiv(GLuint program_id, GLenum program_interface, GLenum pname, 3078 const glw::GLchar* resource_name, GLint expected) const 3079 { 3080 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3081 GLuint index = gl.getProgramResourceIndex(program_id, program_interface, resource_name); 3082 GLint value = 0; 3083 3084 if (GL_INVALID_INDEX == index) 3085 { 3086 return false; 3087 } 3088 3089 gl.getProgramResourceiv(program_id, program_interface, index, 1, &pname, 1, 0, &value); 3090 GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceiv"); 3091 3092 if (expected != value) 3093 { 3094 m_context.getTestContext().getLog() 3095 << tcu::TestLog::Message << "Error. Invalid result. Function: getProgramResourceiv. " 3096 << "Program interface: " << Utils::programInterfaceToStr(program_interface) << ". " 3097 << "Resource name: " << resource_name << ". " 3098 << "Property: " << Utils::pnameToStr(pname) << ". " 3099 << "Result: " << value << ". " 3100 << "Expected: " << expected << "." << tcu::TestLog::EndMessage; 3101 3102 return false; 3103 } 3104 else 3105 { 3106 return true; 3107 } 3108 } 3109 3110 /** Verify result of getProgramInterfaceiv 3111 * 3112 * @param program_id Program object id 3113 * @param program_interface Program interface 3114 * @param pname <pname> parameter for getProgramStageiv 3115 * @param expected Expected value 3116 * 3117 * @return true if result is equal to expected value, flase otherwise 3118 **/ 3119 bool FunctionalTest3_4::checkProgramInterfaceiv(GLuint program_id, GLenum program_interface, GLenum pname, 3120 GLint expected) const 3121 { 3122 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3123 GLint value = 0; 3124 3125 gl.getProgramInterfaceiv(program_id, program_interface, pname, &value); 3126 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInterfaceiv"); 3127 3128 if (expected != value) 3129 { 3130 m_context.getTestContext().getLog() 3131 << tcu::TestLog::Message << "Error. Invalid result. Function: getProgramInterfaceiv. " 3132 << "Program interface: " << Utils::programInterfaceToStr(program_interface) << ". " 3133 << "pname: " << Utils::pnameToStr(pname) << ". " 3134 << "Result: " << value << ". " 3135 << "Expected: " << expected << "." << tcu::TestLog::EndMessage; 3136 3137 return false; 3138 } 3139 else 3140 { 3141 return true; 3142 } 3143 } 3144 3145 /** Verify result of getActiveSubroutineUniformiv 3146 * 3147 * @param program_id Program object id 3148 * @param index <index> parameter for getActiveSubroutineUniformiv 3149 * @param pname <pname> parameter for getActiveSubroutineUniformiv 3150 * @param expected Expected value 3151 * 3152 * @return true if result is equal to expected value, flase otherwise 3153 **/ 3154 bool FunctionalTest3_4::checkActiveSubroutineUniformiv(GLuint program_id, GLuint index, GLenum pname, 3155 GLint expected) const 3156 { 3157 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3158 GLint value = 0; 3159 3160 gl.getActiveSubroutineUniformiv(program_id, GL_VERTEX_SHADER, index, pname, &value); 3161 GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformiv"); 3162 3163 if (expected != value) 3164 { 3165 m_context.getTestContext().getLog() << tcu::TestLog::Message 3166 << "Error. Invalid result. Function: getActiveSubroutineUniformiv. " 3167 << "idnex: " << index << ". " 3168 << "pname: " << Utils::pnameToStr(pname) << ". " 3169 << "Result: " << value << ". " 3170 << "Expected: " << expected << "." << tcu::TestLog::EndMessage; 3171 3172 return false; 3173 } 3174 else 3175 { 3176 return true; 3177 } 3178 } 3179 3180 /** Returns index of program resource 3181 * 3182 * @param program_id Program object id 3183 * @param program_interface Program interface 3184 * @param resource_name Name of resource 3185 * 3186 * @return Index of specified resource 3187 **/ 3188 GLuint FunctionalTest3_4::getProgramResourceIndex(GLuint program_id, GLenum program_interface, 3189 const glw::GLchar* resource_name) const 3190 { 3191 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3192 GLuint index = gl.getProgramResourceIndex(program_id, program_interface, resource_name); 3193 3194 GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceIndex"); 3195 3196 if (GL_INVALID_INDEX == index) 3197 { 3198 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Program resource is not available. " 3199 << "Program interface: " << Utils::programInterfaceToStr(program_interface) 3200 << ". " 3201 << "Resource name: " << resource_name << "." << tcu::TestLog::EndMessage; 3202 } 3203 3204 return index; 3205 } 3206 3207 /** Get subroutine index 3208 * 3209 * @param program_id Program object id 3210 * @param subroutine_name Subroutine name 3211 * @param use_program_query If true getProgramResourceIndex is used, otherwise getSubroutineIndex 3212 * 3213 * @return Index of subroutine 3214 **/ 3215 GLuint FunctionalTest3_4::getSubroutineIndex(GLuint program_id, const glw::GLchar* subroutine_name, 3216 bool use_program_query) const 3217 { 3218 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3219 GLuint index = -1; 3220 3221 if (false == use_program_query) 3222 { 3223 index = gl.getSubroutineIndex(program_id, GL_VERTEX_SHADER, subroutine_name); 3224 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex"); 3225 } 3226 else 3227 { 3228 index = gl.getProgramResourceIndex(program_id, GL_VERTEX_SUBROUTINE, subroutine_name); 3229 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceIndex"); 3230 } 3231 3232 if (GL_INVALID_INDEX == index) 3233 { 3234 TCU_FAIL("Subroutine is not available"); 3235 } 3236 3237 return index; 3238 } 3239 3240 /** Get subroutine uniform location 3241 * 3242 * @param program_id Program object id 3243 * @param uniform_name Subroutine uniform name 3244 * @param use_program_query If true getProgramResourceLocation is used, otherwise getSubroutineUniformLocation 3245 * 3246 * @return Location of subroutine uniform 3247 **/ 3248 GLint FunctionalTest3_4::getSubroutineUniformLocation(GLuint program_id, const glw::GLchar* uniform_name, 3249 bool use_program_query) const 3250 { 3251 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3252 GLint location = -1; 3253 3254 if (false == use_program_query) 3255 { 3256 location = gl.getSubroutineUniformLocation(program_id, GL_VERTEX_SHADER, uniform_name); 3257 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation"); 3258 } 3259 else 3260 { 3261 location = gl.getProgramResourceLocation(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, uniform_name); 3262 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceLocation"); 3263 } 3264 3265 if (-1 == location) 3266 { 3267 TCU_FAIL("Subroutine uniform is not available"); 3268 } 3269 3270 return location; 3271 } 3272 3273 /** Test if getProgramStageiv results are as expected 3274 * 3275 * @param program_id Program object id 3276 * 3277 * @result false in case of invalid result for any pname, true otherwise 3278 **/ 3279 bool FunctionalTest3_4::inspectProgramStageiv(glw::GLuint program_id) const 3280 { 3281 bool result = true; 3282 3283 const inspectionDetails details[] = { 3284 { GL_ACTIVE_SUBROUTINE_UNIFORMS, m_n_active_subroutine_uniforms }, 3285 { GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, m_n_active_subroutine_uniform_locations }, 3286 { GL_ACTIVE_SUBROUTINES, m_n_active_subroutines }, 3287 { GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH, m_n_active_subroutine_uniform_name_length + 1 }, 3288 { GL_ACTIVE_SUBROUTINE_MAX_LENGTH, m_n_active_subroutine_name_length + 1 } 3289 }; 3290 const GLuint n_details = sizeof(details) / sizeof(details[0]); 3291 3292 for (GLuint i = 0; i < n_details; ++i) 3293 { 3294 if (false == checkProgramStageiv(program_id, details[i].pname, details[i].expected_value)) 3295 { 3296 result = false; 3297 } 3298 } 3299 3300 return result; 3301 } 3302 3303 /** Test if checkProgramInterfaceiv results are as expected 3304 * 3305 * @param program_id Program object id 3306 * 3307 * @result false in case of invalid result for any pname, true otherwise 3308 **/ 3309 bool FunctionalTest3_4::inspectProgramInterfaceiv(glw::GLuint program_id) const 3310 { 3311 bool result = true; 3312 3313 const inspectionDetailsForProgramInterface details[] = { 3314 { GL_VERTEX_SUBROUTINE_UNIFORM, GL_ACTIVE_RESOURCES, m_n_active_subroutine_uniforms }, 3315 { GL_VERTEX_SUBROUTINE_UNIFORM, GL_MAX_NAME_LENGTH, m_n_active_subroutine_uniform_name_length + 1 }, 3316 { GL_VERTEX_SUBROUTINE_UNIFORM, GL_MAX_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines }, 3317 { GL_VERTEX_SUBROUTINE, GL_ACTIVE_RESOURCES, m_n_active_subroutines }, 3318 { GL_VERTEX_SUBROUTINE, GL_MAX_NAME_LENGTH, m_n_active_subroutine_name_length + 1 } 3319 }; 3320 const GLuint n_details = sizeof(details) / sizeof(details[0]); 3321 3322 for (GLuint i = 0; i < n_details; ++i) 3323 { 3324 if (false == checkProgramInterfaceiv(program_id, details[i].program_interface, details[i].pname, 3325 details[i].expected_value)) 3326 { 3327 result = false; 3328 } 3329 } 3330 3331 return result; 3332 } 3333 3334 /** Test if checkProgramResourceiv results are as expected 3335 * 3336 * @param program_id Program object id 3337 * @param subroutine_names Array of subroutine names 3338 * @param uniform_names Array of uniform names 3339 * 3340 * @result false in case of invalid result for any pname, true otherwise 3341 **/ 3342 bool FunctionalTest3_4::inspectProgramResourceiv(GLuint program_id, const GLchar** subroutine_names, 3343 const GLchar** uniform_names) const 3344 { 3345 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3346 bool result = true; 3347 3348 for (GLint subroutine = 0; subroutine < m_n_active_subroutines; ++subroutine) 3349 { 3350 const GLchar* subroutine_name = subroutine_names[subroutine]; 3351 const GLint length = (GLint)strlen(subroutine_name) + 1; 3352 3353 if (false == checkProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE, GL_NAME_LENGTH, subroutine_name, length)) 3354 { 3355 result = false; 3356 } 3357 } 3358 3359 inspectionDetails details[] = { 3360 { GL_NAME_LENGTH, 0 }, 3361 { GL_ARRAY_SIZE, 1 }, 3362 { GL_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines }, 3363 { GL_LOCATION, 0 }, 3364 }; 3365 const GLuint n_details = sizeof(details) / sizeof(details[0]); 3366 3367 for (GLint uniform = 0; uniform < m_n_active_subroutine_uniforms; ++uniform) 3368 { 3369 const GLchar* uniform_name = uniform_names[uniform]; 3370 const GLint length = (GLint)strlen(uniform_name) + 1; 3371 const GLint location = getSubroutineUniformLocation(program_id, uniform_name, true); 3372 3373 details[0].expected_value = length; 3374 details[3].expected_value = location; 3375 3376 for (GLuint i = 0; i < n_details; ++i) 3377 { 3378 if (false == checkProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, details[i].pname, 3379 uniform_name, details[i].expected_value)) 3380 { 3381 result = false; 3382 } 3383 } 3384 3385 /* Check compatible subroutines */ 3386 GLuint index = getProgramResourceIndex(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, uniform_name); 3387 3388 if (GL_INVALID_INDEX != index) 3389 { 3390 std::vector<GLint> compatible_subroutines; 3391 GLint index_sum = 0; 3392 GLenum prop = GL_COMPATIBLE_SUBROUTINES; 3393 3394 compatible_subroutines.resize(m_n_active_subroutines); 3395 3396 gl.getProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, index, 1, &prop, m_n_active_subroutines, 3397 0, &compatible_subroutines[0]); 3398 3399 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceiv"); 3400 3401 /* Expected indices are 0, 1, 2, ... N */ 3402 for (GLint i = 0; i < m_n_active_subroutines; ++i) 3403 { 3404 index_sum += compatible_subroutines[i]; 3405 } 3406 3407 /* Sum of E1, ..., EN = (E1 + EN) * N / 2 */ 3408 if (((m_n_active_subroutines - 1) * m_n_active_subroutines) / 2 != index_sum) 3409 { 3410 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 3411 3412 message << "Error. Invalid result. Function: getProgramResourceiv. " 3413 << "Program interface: GL_VERTEX_SUBROUTINE_UNIFORM. " 3414 << "Resource name: " << uniform_name << ". " 3415 << "Property: GL_COMPATIBLE_SUBROUTINES. " 3416 << "Results: "; 3417 3418 for (GLint i = 1; i < m_n_active_subroutines; ++i) 3419 { 3420 message << compatible_subroutines[i]; 3421 } 3422 3423 message << tcu::TestLog::EndMessage; 3424 3425 result = false; 3426 } 3427 } 3428 } 3429 3430 return result; 3431 } 3432 3433 /** Test if getActiveSubroutineUniformiv results are as expected 3434 * 3435 * @param program_id Program object id 3436 * @param uniform_names Array of subroutine uniform names available in program 3437 * 3438 * @result false in case of invalid result for any pname, true otherwise 3439 **/ 3440 bool FunctionalTest3_4::inspectActiveSubroutineUniformiv(GLuint program_id, const GLchar** uniform_names) const 3441 { 3442 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3443 bool result = true; 3444 GLint n_active_subroutine_uniforms = 0; 3445 3446 inspectionDetails details[] = { 3447 { GL_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines }, 3448 { GL_UNIFORM_SIZE, m_n_active_subroutine_uniform_size }, 3449 { GL_UNIFORM_NAME_LENGTH, 0 }, 3450 }; 3451 const GLuint n_details = sizeof(details) / sizeof(details[0]); 3452 3453 /* Get amount of active subroutine uniforms */ 3454 gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); 3455 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); 3456 3457 for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform) 3458 { 3459 GLint name_length = (GLint)strlen(uniform_names[uniform]); 3460 3461 details[2].expected_value = name_length + 1; 3462 3463 /* Checks from "details" */ 3464 for (GLuint i = 0; i < n_details; ++i) 3465 { 3466 if (false == 3467 checkActiveSubroutineUniformiv(program_id, uniform, details[i].pname, details[i].expected_value)) 3468 { 3469 result = false; 3470 } 3471 } 3472 3473 /* Check compatible subroutines */ 3474 std::vector<GLint> compatible_subroutines; 3475 compatible_subroutines.resize(m_n_active_subroutines); 3476 GLint index_sum = 0; 3477 3478 gl.getActiveSubroutineUniformiv(program_id, GL_VERTEX_SHADER, uniform, GL_COMPATIBLE_SUBROUTINES, 3479 &compatible_subroutines[0]); 3480 GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformiv"); 3481 3482 /* Expected indices are 0, 1, 2, ... N */ 3483 for (GLint i = 0; i < m_n_active_subroutines; ++i) 3484 { 3485 index_sum += compatible_subroutines[i]; 3486 } 3487 3488 /* Sum of E1, ..., EN = (E1 + EN) * N / 2 */ 3489 if (((m_n_active_subroutines - 1) * m_n_active_subroutines) / 2 != index_sum) 3490 { 3491 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 3492 3493 message << "Error. Invalid result. Function: getActiveSubroutineUniformiv. idnex: " << uniform 3494 << ". pname: " << Utils::pnameToStr(GL_COMPATIBLE_SUBROUTINES) << ". Results: "; 3495 3496 for (GLint i = 1; i < m_n_active_subroutines; ++i) 3497 { 3498 message << compatible_subroutines[i]; 3499 } 3500 3501 message << tcu::TestLog::EndMessage; 3502 3503 result = false; 3504 } 3505 } 3506 3507 return result; 3508 } 3509 3510 /** Test if getActiveSubroutineUniformName results are as expected 3511 * 3512 * @param program_id Program object id 3513 * @param uniform_names Array of subroutine uniform names available in program 3514 * 3515 * @result false in case of invalid result, true otherwise 3516 **/ 3517 bool FunctionalTest3_4::inspectActiveSubroutineUniformName(GLuint program_id, const GLchar** uniform_names) const 3518 { 3519 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3520 bool result = true; 3521 GLint n_active_subroutine_uniforms = 0; 3522 std::vector<GLchar> active_uniform_name; 3523 3524 gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); 3525 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); 3526 3527 active_uniform_name.resize(m_n_active_subroutine_uniform_name_length + 1); 3528 3529 for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform) 3530 { 3531 bool is_name_ok = false; 3532 3533 gl.getActiveSubroutineUniformName(program_id, GL_VERTEX_SHADER, uniform, (GLsizei)active_uniform_name.size(), 3534 0 /* length */, &active_uniform_name[0]); 3535 GLU_EXPECT_NO_ERROR(gl.getError(), "GetActiveSubroutineUniformName"); 3536 3537 for (GLint name = 0; name < n_active_subroutine_uniforms; ++name) 3538 { 3539 if (0 == strcmp(uniform_names[name], &active_uniform_name[0])) 3540 { 3541 is_name_ok = true; 3542 break; 3543 } 3544 } 3545 3546 if (false == is_name_ok) 3547 { 3548 m_context.getTestContext().getLog() 3549 << tcu::TestLog::Message 3550 << "Error. Invalid result. Function: getActiveSubroutineUniformName. idnex: " << uniform 3551 << ". Result: " << &active_uniform_name[0] << tcu::TestLog::EndMessage; 3552 3553 result = false; 3554 break; 3555 } 3556 } 3557 3558 return result; 3559 } 3560 3561 /** Test if getActiveSubroutineUniformName results are as expected 3562 * 3563 * @param program_id Program object id 3564 * @param subroutine_names Array of subroutine names available in program 3565 * 3566 * @result false in case of invalid result, true otherwise 3567 **/ 3568 bool FunctionalTest3_4::inspectActiveSubroutineName(GLuint program_id, const GLchar** subroutine_names) const 3569 { 3570 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3571 bool result = true; 3572 GLint n_active_subroutines = 0; 3573 std::vector<GLchar> active_subroutine_name; 3574 3575 gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines); 3576 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); 3577 3578 active_subroutine_name.resize(m_n_active_subroutine_name_length + 1); 3579 3580 for (GLint uniform = 0; uniform < n_active_subroutines; ++uniform) 3581 { 3582 bool is_name_ok = false; 3583 3584 gl.getActiveSubroutineName(program_id, GL_VERTEX_SHADER, uniform, (GLsizei)active_subroutine_name.size(), 3585 0 /* length */, &active_subroutine_name[0]); 3586 GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineName"); 3587 3588 for (GLint name = 0; name < n_active_subroutines; ++name) 3589 { 3590 if (0 == strcmp(subroutine_names[name], &active_subroutine_name[0])) 3591 { 3592 is_name_ok = true; 3593 break; 3594 } 3595 } 3596 3597 if (false == is_name_ok) 3598 { 3599 m_context.getTestContext().getLog() 3600 << tcu::TestLog::Message 3601 << "Error. Invalid result. Function: getActiveSubroutineName. idnex: " << uniform 3602 << ". Result: " << &active_subroutine_name[0] << tcu::TestLog::EndMessage; 3603 3604 result = false; 3605 break; 3606 } 3607 } 3608 3609 return result; 3610 } 3611 3612 /** Test if it is possible to "bind" all subroutines uniforms with all subroutines 3613 * 3614 * @param program_id Program object id 3615 * @param subroutine_names Array of subroutine names available in program 3616 * @param uniform_names Array of subroutine uniform names available in program 3617 * 3618 * @result false in case of invalid result, true otherwise 3619 **/ 3620 bool FunctionalTest3_4::inspectSubroutineBinding(GLuint program_id, const GLchar** subroutine_names, 3621 const GLchar** uniform_names, bool use_program_query) const 3622 { 3623 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3624 bool result = true; 3625 GLint n_active_subroutines = 0; 3626 GLint n_active_subroutine_uniforms = 0; 3627 std::vector<GLuint> subroutine_uniforms; 3628 GLuint queried_subroutine_index = 0; 3629 3630 gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines); 3631 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); 3632 3633 gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); 3634 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); 3635 3636 subroutine_uniforms.resize(n_active_subroutine_uniforms); 3637 3638 for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform) 3639 { 3640 GLuint uniform_location = getSubroutineUniformLocation(program_id, uniform_names[uniform], use_program_query); 3641 3642 for (GLint routine = 0; routine < n_active_subroutines; ++routine) 3643 { 3644 GLuint routine_index = getSubroutineIndex(program_id, subroutine_names[routine], use_program_query); 3645 3646 subroutine_uniforms[uniform] = routine_index; 3647 3648 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_active_subroutine_uniforms, &subroutine_uniforms[0]); 3649 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 3650 3651 gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, uniform_location, &queried_subroutine_index); 3652 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv"); 3653 3654 if (queried_subroutine_index != routine_index) 3655 { 3656 m_context.getTestContext().getLog() 3657 << tcu::TestLog::Message << "Error. Invalid result. Function: gl.getUniformSubroutineuiv." 3658 << " Subroutine uniform: " << uniform << ", name: " << uniform_names[uniform] 3659 << ", location: " << uniform_location << ". Subroutine: " << routine 3660 << ", name: " << subroutine_names[routine] << ", index: " << routine_index 3661 << ". Result: " << queried_subroutine_index << tcu::TestLog::EndMessage; 3662 3663 result = false; 3664 } 3665 } 3666 } 3667 3668 return result; 3669 } 3670 3671 /** Execute draw call and verify results 3672 * 3673 * @param program_id Program object id 3674 * @param first_routine_name Name of subroutine that shall be used aas first_routine 3675 * @param second_routine_name Name of subroutine that shall be used aas second_routine 3676 * @param uniform_names Name of uniforms 3677 * @param expected_results Test data. [0] is used as input data. All are used as expected_results 3678 * @param use_program_query If true GetProgram* API will be used 3679 * 3680 * @return false in case of invalid result, true otherwise 3681 **/ 3682 bool FunctionalTest3_4::testDraw(GLuint program_id, const GLchar* first_routine_name, const GLchar* second_routine_name, 3683 const GLchar** uniform_names, const Utils::vec4<GLfloat> expected_results[5], 3684 bool use_program_query) const 3685 { 3686 static const GLuint n_varyings = 5; 3687 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3688 bool result = true; 3689 GLuint subroutine_uniforms[2] = { 0 }; 3690 3691 /* Get subroutine uniform locations */ 3692 GLint first_routine_location = getSubroutineUniformLocation(program_id, uniform_names[0], use_program_query); 3693 3694 GLint second_routine_location = getSubroutineUniformLocation(program_id, uniform_names[1], use_program_query); 3695 3696 /* Get subroutine indices */ 3697 GLuint first_routine_index = getSubroutineIndex(program_id, first_routine_name, use_program_query); 3698 3699 GLuint second_routine_index = getSubroutineIndex(program_id, second_routine_name, use_program_query); 3700 3701 /* Map uniforms with subroutines */ 3702 subroutine_uniforms[first_routine_location] = first_routine_index; 3703 subroutine_uniforms[second_routine_location] = second_routine_index; 3704 3705 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 2 /* number of uniforms */, &subroutine_uniforms[0]); 3706 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 3707 3708 /* Get location of input_data */ 3709 GLint input_data_location = gl.getUniformLocation(program_id, "input_data"); 3710 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); 3711 3712 if (-1 == input_data_location) 3713 { 3714 TCU_FAIL("Uniform is not available"); 3715 } 3716 3717 /* Set up input_data */ 3718 gl.uniform4f(input_data_location, expected_results[0].m_x, expected_results[0].m_y, expected_results[0].m_z, 3719 expected_results[0].m_w); 3720 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 3721 3722 /* Execute draw call with transform feedback */ 3723 gl.beginTransformFeedback(GL_POINTS); 3724 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 3725 3726 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 3727 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 3728 3729 gl.endTransformFeedback(); 3730 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 3731 3732 /* Verify results */ 3733 GLfloat* feedback_data = (GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 3734 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 3735 3736 Utils::vec4<GLfloat> results[5]; 3737 3738 results[0].m_x = feedback_data[0]; 3739 results[0].m_y = feedback_data[1]; 3740 results[0].m_z = feedback_data[2]; 3741 results[0].m_w = feedback_data[3]; 3742 3743 results[1].m_x = feedback_data[4]; 3744 results[1].m_y = feedback_data[5]; 3745 results[1].m_z = feedback_data[6]; 3746 results[1].m_w = feedback_data[7]; 3747 3748 results[2].m_x = feedback_data[8]; 3749 results[2].m_y = feedback_data[9]; 3750 results[2].m_z = feedback_data[10]; 3751 results[2].m_w = feedback_data[11]; 3752 3753 results[3].m_x = feedback_data[12]; 3754 results[3].m_y = feedback_data[13]; 3755 results[3].m_z = feedback_data[14]; 3756 results[3].m_w = feedback_data[15]; 3757 3758 results[4].m_x = feedback_data[16]; 3759 results[4].m_y = feedback_data[17]; 3760 results[4].m_z = feedback_data[18]; 3761 results[4].m_w = feedback_data[19]; 3762 3763 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 3764 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 3765 3766 for (GLuint i = 0; i < n_varyings; ++i) 3767 { 3768 result = result && (results[i] == expected_results[i]); 3769 } 3770 3771 if (false == result) 3772 { 3773 m_context.getTestContext().getLog() << tcu::TestLog::Message 3774 << "Error. Invalid result. First routine: " << first_routine_name 3775 << ". Second routine: " << second_routine_name << tcu::TestLog::EndMessage; 3776 3777 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 3778 3779 message << "Results:"; 3780 3781 for (GLuint i = 0; i < n_varyings; ++i) 3782 { 3783 results[i].log(message); 3784 } 3785 3786 message << tcu::TestLog::EndMessage; 3787 3788 message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 3789 3790 message << "Expected:"; 3791 3792 for (GLuint i = 0; i < n_varyings; ++i) 3793 { 3794 expected_results[i].log(message); 3795 } 3796 3797 message << tcu::TestLog::EndMessage; 3798 } 3799 3800 return result; 3801 } 3802 3803 /** Constructor 3804 * 3805 * @param context CTS context 3806 **/ 3807 FunctionalTest5::FunctionalTest5(deqp::Context& context) 3808 : TestCase(context, "eight_subroutines_four_uniforms", "Verify multiple subroutine sets") 3809 { 3810 } 3811 3812 /** Execute test 3813 * 3814 * @return tcu::TestNode::STOP 3815 **/ 3816 tcu::TestNode::IterateResult FunctionalTest5::iterate() 3817 { 3818 static const GLchar* vertex_shader_code = 3819 "#version 400 core\n" 3820 "#extension GL_ARB_shader_subroutine : require\n" 3821 "\n" 3822 "precision highp float;\n" 3823 "\n" 3824 "// Subroutine types\n" 3825 "subroutine vec4 routine_type_1(in vec4 left, in vec4 right);\n" 3826 "subroutine vec4 routine_type_2(in vec4 iparam);\n" 3827 "subroutine vec4 routine_type_3(in vec4 a, in vec4 b, in vec4 c);\n" 3828 "subroutine bvec4 routine_type_4(in vec4 left, in vec4 right);\n" 3829 "\n" 3830 "// Subroutine definitions\n" 3831 "// 1st type\n" 3832 "subroutine(routine_type_1) vec4 add(in vec4 left, in vec4 right)\n" 3833 "{\n" 3834 " return left + right;\n" 3835 "}\n" 3836 "\n" 3837 "subroutine(routine_type_1) vec4 subtract(in vec4 left, in vec4 right)\n" 3838 "{\n" 3839 " return left - right;\n" 3840 "}\n" 3841 "\n" 3842 "// 2nd type\n" 3843 "subroutine(routine_type_2) vec4 square(in vec4 iparam)\n" 3844 "{\n" 3845 " return iparam * iparam;\n" 3846 "}\n" 3847 "\n" 3848 "subroutine(routine_type_2) vec4 square_root(in vec4 iparam)\n" 3849 "{\n" 3850 " return sqrt(iparam);\n" 3851 "}\n" 3852 "\n" 3853 "// 3rd type\n" 3854 "subroutine(routine_type_3) vec4 do_fma(in vec4 a, in vec4 b, in vec4 c)\n" 3855 "{\n" 3856 " return fma(a, b, c);\n" 3857 "}\n" 3858 "\n" 3859 "subroutine(routine_type_3) vec4 blend(in vec4 a, in vec4 b, in vec4 c)\n" 3860 "{\n" 3861 " return c * a + (vec4(1) - c) * b;\n" 3862 "}\n" 3863 "\n" 3864 "// 4th type\n" 3865 "subroutine(routine_type_4) bvec4 are_equal(in vec4 left, in vec4 right)\n" 3866 "{\n" 3867 " return equal(left, right);\n" 3868 "}\n" 3869 "\n" 3870 "subroutine(routine_type_4) bvec4 are_greater(in vec4 left, in vec4 right)\n" 3871 "{\n" 3872 " return greaterThan(left, right);\n" 3873 "}\n" 3874 "\n" 3875 "// Sub routine uniforms\n" 3876 "subroutine uniform routine_type_1 first_routine;\n" 3877 "subroutine uniform routine_type_2 second_routine;\n" 3878 "subroutine uniform routine_type_3 third_routine;\n" 3879 "subroutine uniform routine_type_4 fourth_routine;\n" 3880 "\n" 3881 "// Input data\n" 3882 "uniform vec4 first_input;\n" 3883 "uniform vec4 second_input;\n" 3884 "uniform vec4 third_input;\n" 3885 "\n" 3886 "// Output\n" 3887 "out vec4 out_result_from_first_routine;\n" 3888 "out vec4 out_result_from_second_routine;\n" 3889 "out vec4 out_result_from_third_routine;\n" 3890 "out uvec4 out_result_from_fourth_routine;\n" 3891 "\n" 3892 "void main()\n" 3893 "{\n" 3894 " out_result_from_first_routine = first_routine (first_input, second_input);\n" 3895 " out_result_from_second_routine = second_routine(first_input);\n" 3896 " out_result_from_third_routine = third_routine (first_input, second_input, third_input);\n" 3897 " out_result_from_fourth_routine = uvec4(fourth_routine(first_input, second_input));\n" 3898 "}\n" 3899 "\n"; 3900 3901 static const GLchar* subroutine_names[4][2] = { 3902 { "add", "subtract" }, { "square", "square_root" }, { "do_fma", "blend" }, { "are_equal", "are_greater" } 3903 }; 3904 3905 static const GLchar* subroutine_uniform_names[4][1] = { 3906 { "first_routine" }, { "second_routine" }, { "third_routine" }, { "fourth_routine" } 3907 }; 3908 3909 static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]); 3910 static const GLuint n_subroutines_per_type = sizeof(subroutine_names[0]) / sizeof(subroutine_names[0][0]); 3911 static const GLuint n_subroutine_uniforms_per_type = 3912 sizeof(subroutine_uniform_names[0]) / sizeof(subroutine_uniform_names[0][0]); 3913 3914 static const GLchar* uniform_names[] = { "first_input", "second_input", "third_input" }; 3915 static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]); 3916 3917 static const GLchar* varying_names[] = { "out_result_from_first_routine", "out_result_from_second_routine", 3918 "out_result_from_third_routine", "out_result_from_fourth_routine" }; 3919 static const GLuint n_varyings = sizeof(varying_names) / sizeof(varying_names[0]); 3920 static const GLuint transform_feedback_buffer_size = n_varyings * sizeof(GLfloat) * 4 /* vec4 */; 3921 3922 /* Test data */ 3923 static const Utils::vec4<GLfloat> input_data[3] = { Utils::vec4<GLfloat>(1.0f, 4.0f, 9.0f, 16.0f), 3924 Utils::vec4<GLfloat>(16.0f, 9.0f, 4.0f, 1.0f), 3925 Utils::vec4<GLfloat>(0.25f, 0.5f, 0.75f, 1.0f) }; 3926 3927 static const Utils::vec4<GLfloat> expected_result_from_first_routine[2] = { 3928 Utils::vec4<GLfloat>(17.0f, 13.0f, 13.0f, 17.0f), Utils::vec4<GLfloat>(-15.0f, -5.0f, 5.0f, 15.0f) 3929 }; 3930 3931 static const Utils::vec4<GLfloat> expected_result_from_second_routine[2] = { 3932 Utils::vec4<GLfloat>(1.0f, 16.0f, 81.0f, 256.0f), Utils::vec4<GLfloat>(1.0f, 2.0f, 3.0f, 4.0f) 3933 }; 3934 3935 static const Utils::vec4<GLfloat> expected_result_from_third_routine[2] = { 3936 Utils::vec4<GLfloat>(16.25f, 36.5f, 36.75f, 17.0f), Utils::vec4<GLfloat>(12.25f, 6.5f, 7.75f, 16.0f) 3937 }; 3938 3939 static const Utils::vec4<GLuint> expected_result_from_fourth_routine[2] = { Utils::vec4<GLuint>(0, 0, 0, 0), 3940 Utils::vec4<GLuint>(0, 0, 1, 1) }; 3941 3942 /* All combinations of subroutines */ 3943 static const GLuint subroutine_combinations[][4] = { 3944 { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 0, 0, 1, 0 }, { 0, 0, 1, 1 }, { 0, 1, 0, 0 }, { 0, 1, 0, 1 }, 3945 { 0, 1, 1, 0 }, { 0, 1, 1, 1 }, { 1, 0, 0, 0 }, { 1, 0, 0, 1 }, { 1, 0, 1, 0 }, { 1, 0, 1, 1 }, 3946 { 1, 1, 0, 0 }, { 1, 1, 0, 1 }, { 1, 1, 1, 0 }, { 1, 1, 1, 1 } 3947 }; 3948 static const GLuint n_subroutine_combinations = 3949 sizeof(subroutine_combinations) / sizeof(subroutine_combinations[0]); 3950 3951 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 3952 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 3953 { 3954 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 3955 } 3956 3957 /* Result */ 3958 bool result = true; 3959 3960 /* GL objects */ 3961 Utils::program program(m_context); 3962 Utils::buffer transform_feedback_buffer(m_context); 3963 Utils::vertexArray vao(m_context); 3964 3965 /* Init GL objects */ 3966 program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names, 3967 n_varyings); 3968 3969 program.use(); 3970 3971 vao.generate(); 3972 vao.bind(); 3973 3974 transform_feedback_buffer.generate(); 3975 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, 3976 GL_DYNAMIC_COPY); 3977 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); 3978 3979 /* Get subroutine uniform locations and subroutine indices */ 3980 for (GLuint type = 0; type < n_subroutine_types; ++type) 3981 { 3982 for (GLuint uniform = 0; uniform < n_subroutine_uniforms_per_type; ++uniform) 3983 { 3984 m_subroutine_uniform_locations[type][uniform] = 3985 program.getSubroutineUniformLocation(subroutine_uniform_names[type][uniform], GL_VERTEX_SHADER); 3986 } 3987 3988 for (GLuint routine = 0; routine < n_subroutines_per_type; ++routine) 3989 { 3990 m_subroutine_indices[type][routine] = 3991 program.getSubroutineIndex(subroutine_names[type][routine], GL_VERTEX_SHADER); 3992 } 3993 } 3994 3995 /* Get uniform locations */ 3996 for (GLuint i = 0; i < n_uniform_names; ++i) 3997 { 3998 m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]); 3999 } 4000 4001 /* Draw with each routine combination */ 4002 for (GLuint i = 0; i < n_subroutine_combinations; ++i) 4003 { 4004 Utils::vec4<GLfloat> first_routine_result; 4005 Utils::vec4<GLfloat> second_routine_result; 4006 Utils::vec4<GLfloat> third_routine_result; 4007 Utils::vec4<GLuint> fourth_routine_result; 4008 4009 testDraw(subroutine_combinations[i], input_data, first_routine_result, second_routine_result, 4010 third_routine_result, fourth_routine_result); 4011 4012 if (false == verify(first_routine_result, second_routine_result, third_routine_result, fourth_routine_result, 4013 expected_result_from_first_routine[subroutine_combinations[i][0]], 4014 expected_result_from_second_routine[subroutine_combinations[i][1]], 4015 expected_result_from_third_routine[subroutine_combinations[i][2]], 4016 expected_result_from_fourth_routine[subroutine_combinations[i][3]])) 4017 { 4018 logError(subroutine_names, subroutine_combinations[i], input_data, first_routine_result, 4019 second_routine_result, third_routine_result, fourth_routine_result, 4020 expected_result_from_first_routine[subroutine_combinations[i][0]], 4021 expected_result_from_second_routine[subroutine_combinations[i][1]], 4022 expected_result_from_third_routine[subroutine_combinations[i][2]], 4023 expected_result_from_fourth_routine[subroutine_combinations[i][3]]); 4024 4025 result = false; 4026 } 4027 } 4028 4029 /* Done */ 4030 if (true == result) 4031 { 4032 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 4033 } 4034 else 4035 { 4036 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 4037 } 4038 4039 return tcu::TestNode::STOP; 4040 } 4041 4042 /** Log error message 4043 * 4044 * @param subroutine_names Array of subroutine names 4045 * @param subroutine_combination Combination of subroutines 4046 * @param input_data Input data 4047 * @param first_routine_result Result of first routine 4048 * @param second_routine_result Result of second routine 4049 * @param third_routine_result Result of third routine 4050 * @param fourth_routine_result Result of fourth routine 4051 * @param first_routine_expected_result Expected result of first routine 4052 * @param second_routine_expected_result Expected result of second routine 4053 * @param third_routine_expected_result Expected result of third routine 4054 * @param fourth_routine_expected_result Expected result of fourth routine 4055 **/ 4056 void FunctionalTest5::logError(const glw::GLchar* subroutine_names[4][2], const glw::GLuint subroutine_combination[4], 4057 const Utils::vec4<glw::GLfloat> input_data[3], 4058 const Utils::vec4<glw::GLfloat>& first_routine_result, 4059 const Utils::vec4<glw::GLfloat>& second_routine_result, 4060 const Utils::vec4<glw::GLfloat>& third_routine_result, 4061 const Utils::vec4<glw::GLuint>& fourth_routine_result, 4062 const Utils::vec4<glw::GLfloat>& first_routine_expected_result, 4063 const Utils::vec4<glw::GLfloat>& second_routine_expected_result, 4064 const Utils::vec4<glw::GLfloat>& third_routine_expected_result, 4065 const Utils::vec4<glw::GLuint>& fourth_routine_expected_result) const 4066 { 4067 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." 4068 << tcu::TestLog::EndMessage; 4069 4070 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4071 4072 message << "Function: " << subroutine_names[0][subroutine_combination[0]] << "( "; 4073 input_data[0].log(message); 4074 message << ", "; 4075 input_data[1].log(message); 4076 message << " ). Result: "; 4077 first_routine_result.log(message); 4078 message << ". Expected: "; 4079 first_routine_expected_result.log(message); 4080 4081 message << tcu::TestLog::EndMessage; 4082 4083 message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4084 4085 message << "Function: " << subroutine_names[1][subroutine_combination[1]] << "( "; 4086 input_data[0].log(message); 4087 message << " ). Result: "; 4088 second_routine_result.log(message); 4089 message << ". Expected: "; 4090 second_routine_expected_result.log(message); 4091 4092 message << tcu::TestLog::EndMessage; 4093 4094 message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4095 4096 message << "Function: " << subroutine_names[2][subroutine_combination[2]] << "( "; 4097 input_data[0].log(message); 4098 message << ", "; 4099 input_data[1].log(message); 4100 message << ", "; 4101 input_data[2].log(message); 4102 message << "). Result: "; 4103 third_routine_result.log(message); 4104 message << ". Expected: "; 4105 third_routine_expected_result.log(message); 4106 4107 message << tcu::TestLog::EndMessage; 4108 4109 message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4110 4111 message << "Function: " << subroutine_names[3][subroutine_combination[3]] << "( "; 4112 input_data[0].log(message); 4113 message << ", "; 4114 input_data[1].log(message); 4115 message << ", "; 4116 message << " ). Result: "; 4117 fourth_routine_result.log(message); 4118 message << ". Expected: "; 4119 fourth_routine_expected_result.log(message); 4120 4121 message << tcu::TestLog::EndMessage; 4122 } 4123 4124 /** Execute draw call and capture results 4125 * 4126 * @param subroutine_combination Combination of subroutines 4127 * @param input_data Input data 4128 * @param out_first_routine_result Result of first routine 4129 * @param out_second_routine_result Result of second routine 4130 * @param out_third_routine_result Result of third routine 4131 * @param out_fourth_routine_result Result of fourth routine 4132 **/ 4133 void FunctionalTest5::testDraw(const glw::GLuint subroutine_combination[4], 4134 const Utils::vec4<glw::GLfloat> input_data[3], 4135 Utils::vec4<glw::GLfloat>& out_first_routine_result, 4136 Utils::vec4<glw::GLfloat>& out_second_routine_result, 4137 Utils::vec4<glw::GLfloat>& out_third_routine_result, 4138 Utils::vec4<glw::GLuint>& out_fourth_routine_result) const 4139 { 4140 static const GLuint n_uniforms = sizeof(m_uniform_locations) / sizeof(m_uniform_locations[0]); 4141 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4142 GLuint subroutine_indices[4]; 4143 static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); 4144 4145 /* Prepare subroutine uniform data */ 4146 for (GLuint i = 0; i < n_subroutine_uniforms; ++i) 4147 { 4148 const GLuint location = m_subroutine_uniform_locations[i][0]; 4149 4150 subroutine_indices[location] = m_subroutine_indices[i][subroutine_combination[i]]; 4151 } 4152 4153 /* Set up subroutine uniforms */ 4154 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); 4155 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 4156 4157 /* Set up input data uniforms */ 4158 for (GLuint i = 0; i < n_uniforms; ++i) 4159 { 4160 gl.uniform4f(m_uniform_locations[i], input_data[i].m_x, input_data[i].m_y, input_data[i].m_z, 4161 input_data[i].m_w); 4162 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 4163 } 4164 4165 /* Execute draw call with transform feedback */ 4166 gl.beginTransformFeedback(GL_POINTS); 4167 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 4168 4169 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 4170 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 4171 4172 gl.endTransformFeedback(); 4173 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 4174 4175 /* Capture results */ 4176 GLvoid* feedback_data = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 4177 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 4178 4179 GLfloat* float_ptr = (GLfloat*)feedback_data; 4180 4181 /* First result */ 4182 out_first_routine_result.m_x = float_ptr[0]; 4183 out_first_routine_result.m_y = float_ptr[1]; 4184 out_first_routine_result.m_z = float_ptr[2]; 4185 out_first_routine_result.m_w = float_ptr[3]; 4186 4187 /* Second result */ 4188 out_second_routine_result.m_x = float_ptr[4]; 4189 out_second_routine_result.m_y = float_ptr[5]; 4190 out_second_routine_result.m_z = float_ptr[6]; 4191 out_second_routine_result.m_w = float_ptr[7]; 4192 4193 /* Third result */ 4194 out_third_routine_result.m_x = float_ptr[8]; 4195 out_third_routine_result.m_y = float_ptr[9]; 4196 out_third_routine_result.m_z = float_ptr[10]; 4197 out_third_routine_result.m_w = float_ptr[11]; 4198 4199 /* Fourth result */ 4200 GLuint* uint_ptr = (GLuint*)(float_ptr + 12); 4201 out_fourth_routine_result.m_x = uint_ptr[0]; 4202 out_fourth_routine_result.m_y = uint_ptr[1]; 4203 out_fourth_routine_result.m_z = uint_ptr[2]; 4204 out_fourth_routine_result.m_w = uint_ptr[3]; 4205 4206 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 4207 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 4208 } 4209 4210 /** Verify if results match expected results 4211 * 4212 * @param first_routine_result Result of first routine 4213 * @param second_routine_result Result of second routine 4214 * @param third_routine_result Result of third routine 4215 * @param fourth_routine_result Result of fourth routine 4216 * @param first_routine_expected_result Expected result of first routine 4217 * @param second_routine_expected_result Expected result of second routine 4218 * @param third_routine_expected_result Expected result of third routine 4219 * @param fourth_routine_expected_result Expected result of fourth routine 4220 **/ 4221 bool FunctionalTest5::verify(const Utils::vec4<glw::GLfloat>& first_routine_result, 4222 const Utils::vec4<glw::GLfloat>& second_routine_result, 4223 const Utils::vec4<glw::GLfloat>& third_routine_result, 4224 const Utils::vec4<glw::GLuint>& fourth_routine_result, 4225 const Utils::vec4<glw::GLfloat>& first_routine_expected_result, 4226 const Utils::vec4<glw::GLfloat>& second_routine_expected_result, 4227 const Utils::vec4<glw::GLfloat>& third_routine_expected_result, 4228 const Utils::vec4<glw::GLuint>& fourth_routine_expected_result) const 4229 { 4230 bool result = true; 4231 4232 result = result && (first_routine_result == first_routine_expected_result); 4233 result = result && (second_routine_result == second_routine_expected_result); 4234 result = result && (third_routine_result == third_routine_expected_result); 4235 result = result && (fourth_routine_result == fourth_routine_expected_result); 4236 4237 return result; 4238 } 4239 4240 /** Constructor 4241 * 4242 * @param context CTS context 4243 **/ 4244 FunctionalTest6::FunctionalTest6(deqp::Context& context) 4245 : TestCase(context, "static_subroutine_call", "Verify that subroutine can be called in a static manner") 4246 { 4247 } 4248 4249 /** Execute test 4250 * 4251 * @return tcu::TestNode::STOP 4252 **/ 4253 tcu::TestNode::IterateResult FunctionalTest6::iterate() 4254 { 4255 static const GLchar* vertex_shader_code = "#version 400 core\n" 4256 "#extension GL_ARB_shader_subroutine : require\n" 4257 "\n" 4258 "precision highp float;\n" 4259 "\n" 4260 "// Subroutine type\n" 4261 "subroutine vec4 routine_type(in vec4 iparam);\n" 4262 "\n" 4263 "// Subroutine definition\n" 4264 "subroutine(routine_type) vec4 square(in vec4 iparam)\n" 4265 "{\n" 4266 " return iparam * iparam;\n" 4267 "}\n" 4268 "\n" 4269 "// Sub routine uniform\n" 4270 "subroutine uniform routine_type routine;\n" 4271 "\n" 4272 "// Input data\n" 4273 "uniform vec4 input_data;\n" 4274 "\n" 4275 "// Output\n" 4276 "out vec4 out_result;\n" 4277 "\n" 4278 "void main()\n" 4279 "{\n" 4280 " out_result = square(input_data);\n" 4281 "}\n" 4282 "\n"; 4283 4284 static const GLchar* varying_name = "out_result"; 4285 4286 /* Test data */ 4287 static const Utils::vec4<GLfloat> input_data(1.0f, 4.0f, 9.0f, 16.0f); 4288 4289 static const Utils::vec4<GLfloat> expected_result(1.0f, 16.0f, 81.0f, 256.0f); 4290 4291 static const GLuint transform_feedback_buffer_size = 4 * sizeof(GLfloat); 4292 4293 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 4294 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 4295 { 4296 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 4297 } 4298 4299 /* GL objects */ 4300 Utils::program program(m_context); 4301 Utils::buffer transform_feedback_buffer(m_context); 4302 Utils::vertexArray vao(m_context); 4303 4304 /* Init GL objects */ 4305 program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, &varying_name, 4306 1 /* n_varyings */); 4307 4308 program.use(); 4309 4310 vao.generate(); 4311 vao.bind(); 4312 4313 transform_feedback_buffer.generate(); 4314 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, 4315 GL_DYNAMIC_COPY); 4316 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); 4317 4318 /* Test */ 4319 { 4320 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4321 const GLint uniform_location = gl.getUniformLocation(program.m_program_object_id, "input_data"); 4322 4323 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); 4324 4325 if (-1 == uniform_location) 4326 { 4327 TCU_FAIL("Uniform is not available"); 4328 } 4329 4330 /* Set up input data uniforms */ 4331 gl.uniform4f(uniform_location, input_data.m_x, input_data.m_y, input_data.m_z, input_data.m_w); 4332 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 4333 4334 /* Execute draw call with transform feedback */ 4335 gl.beginTransformFeedback(GL_POINTS); 4336 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 4337 4338 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 4339 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 4340 4341 gl.endTransformFeedback(); 4342 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 4343 4344 /* Capture results */ 4345 GLfloat* feedback_data = (GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 4346 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 4347 4348 Utils::vec4<GLfloat> result(feedback_data[0], feedback_data[1], feedback_data[2], feedback_data[3]); 4349 4350 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 4351 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 4352 4353 /* Verify */ 4354 if (expected_result == result) 4355 { 4356 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 4357 } 4358 else 4359 { 4360 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." 4361 << tcu::TestLog::EndMessage; 4362 4363 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4364 4365 message << "Function: square( "; 4366 input_data.log(message); 4367 message << " ). Result: "; 4368 result.log(message); 4369 message << ". Expected: "; 4370 expected_result.log(message); 4371 4372 message << tcu::TestLog::EndMessage; 4373 4374 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 4375 } 4376 } 4377 4378 /* Done */ 4379 return tcu::TestNode::STOP; 4380 } 4381 4382 /** Constructor 4383 * 4384 * @param context CTS context 4385 **/ 4386 FunctionalTest7_8::FunctionalTest7_8(deqp::Context& context) 4387 : TestCase(context, "arrayed_subroutine_uniforms", "Verify that subroutine can be called in a static manner") 4388 { 4389 } 4390 4391 /** Execute test 4392 * 4393 * @return tcu::TestNode::STOP 4394 **/ 4395 tcu::TestNode::IterateResult FunctionalTest7_8::iterate() 4396 { 4397 static const GLchar* vertex_shader_code = 4398 "#version 400 core\n" 4399 "#extension GL_ARB_shader_subroutine : require\n" 4400 "\n" 4401 "precision highp float;\n" 4402 "\n" 4403 "// Subroutine type\n" 4404 "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n" 4405 "\n" 4406 "// Subroutine definitions\n" 4407 "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n" 4408 "{\n" 4409 " return left + right;\n" 4410 "}\n" 4411 "\n" 4412 "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n" 4413 "{\n" 4414 " return left * right;\n" 4415 "}\n" 4416 "\n" 4417 "// Sub routine uniform\n" 4418 "subroutine uniform routine_type routine[4];\n" 4419 "\n" 4420 "// Input data\n" 4421 "uniform vec4 uni_left;\n" 4422 "uniform vec4 uni_right;\n" 4423 "uniform uvec4 uni_indices;\n" 4424 "\n" 4425 "// Output\n" 4426 "out vec4 out_combined;\n" 4427 "out vec4 out_combined_inverted;\n" 4428 "out vec4 out_constant;\n" 4429 "out vec4 out_constant_inverted;\n" 4430 "out vec4 out_dynamic;\n" 4431 "out vec4 out_dynamic_inverted;\n" 4432 "out vec4 out_loop;\n" 4433 "out uint out_array_length;\n" 4434 "\n" 4435 "void main()\n" 4436 "{\n" 4437 " out_combined = routine[3](routine[2](routine[1](routine[0](uni_left, uni_right), uni_right), " 4438 "uni_right), uni_right);\n" 4439 " out_combined_inverted = routine[0](routine[1](routine[2](routine[3](uni_left, uni_right), uni_right), " 4440 "uni_right), uni_right);\n" 4441 " \n" 4442 " out_constant = routine[3](routine[2](routine[1](routine[0](vec4(1, 2, 3, 4), vec4(-5, -6, -7, " 4443 "-8)), vec4(-1, -2, -3, -4)), vec4(5, 6, 7, 8)), vec4(1, 2, 3, 4));\n" 4444 " out_constant_inverted = routine[0](routine[1](routine[2](routine[3](vec4(1, 2, 3, 4), vec4(-5, -6, -7, " 4445 "-8)), vec4(-1, -2, -3, -4)), vec4(5, 6, 7, 8)), vec4(1, 2, 3, 4));\n" 4446 " \n" 4447 " out_dynamic = " 4448 "routine[uni_indices.w](routine[uni_indices.z](routine[uni_indices.y](routine[uni_indices.x](uni_left, " 4449 "uni_right), uni_right), uni_right), uni_right);\n" 4450 " out_dynamic_inverted = " 4451 "routine[uni_indices.x](routine[uni_indices.y](routine[uni_indices.z](routine[uni_indices.w](uni_left, " 4452 "uni_right), uni_right), uni_right), uni_right);\n" 4453 " \n" 4454 " out_loop = uni_left;\n" 4455 " for (uint i = 0u; i < routine.length(); ++i)\n" 4456 " {\n" 4457 " out_loop = routine[i](out_loop, uni_right);\n" 4458 " }\n" 4459 " \n" 4460 " out_array_length = routine.length() + 6 - (uni_indices.x + uni_indices.y + uni_indices.z + " 4461 "uni_indices.w);\n" 4462 "}\n" 4463 "\n"; 4464 4465 static const GLchar* subroutine_names[] = { 4466 "add", "multiply", 4467 }; 4468 static const GLuint n_subroutine_names = sizeof(subroutine_names) / sizeof(subroutine_names[0]); 4469 4470 static const GLchar* subroutine_uniform_names[] = { "routine[0]", "routine[1]", "routine[2]", "routine[3]" }; 4471 static const GLuint n_subroutine_uniform_names = 4472 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); 4473 4474 static const GLchar* uniform_names[] = { 4475 "uni_left", "uni_right", "uni_indices", 4476 }; 4477 static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]); 4478 4479 static const GLchar* varying_names[] = { "out_combined", "out_combined_inverted", 4480 "out_constant", "out_constant_inverted", 4481 "out_dynamic", "out_dynamic_inverted", 4482 "out_loop", "out_array_length" }; 4483 4484 static const GLuint n_varyings = sizeof(varying_names) / sizeof(varying_names[0]); 4485 static const GLuint transform_feedback_buffer_size = n_varyings * 4 * sizeof(GLfloat); 4486 4487 /* Test data */ 4488 static const Utils::vec4<GLfloat> uni_left(-1.0f, 0.75f, -0.5f, 0.25f); 4489 static const Utils::vec4<GLfloat> uni_right(1.0f, -0.75f, 0.5f, -0.25f); 4490 static const Utils::vec4<GLuint> uni_indices(1, 2, 0, 3); 4491 4492 static const GLuint subroutine_combinations[][4] = { 4493 { 0, 0, 0, 0 }, /* + + + + */ 4494 { 0, 0, 0, 1 }, /* + + + * */ 4495 { 0, 0, 1, 0 }, /* + + * + */ 4496 { 0, 0, 1, 1 }, /* + + * * */ 4497 { 0, 1, 0, 0 }, /* + * + + */ 4498 { 0, 1, 0, 1 }, /* + * + * */ 4499 { 0, 1, 1, 0 }, /* + * * + */ 4500 { 0, 1, 1, 1 }, /* + * * * */ 4501 { 1, 0, 0, 0 }, /* * + + + */ 4502 { 1, 0, 0, 1 }, /* * + + * */ 4503 { 1, 0, 1, 0 }, /* * + * + */ 4504 { 1, 0, 1, 1 }, /* * + * * */ 4505 { 1, 1, 0, 0 }, /* * * + + */ 4506 { 1, 1, 0, 1 }, /* * * + * */ 4507 { 1, 1, 1, 0 }, /* * * * + */ 4508 { 1, 1, 1, 1 } /* * * * * */ 4509 }; 4510 static const GLuint n_subroutine_combinations = 4511 sizeof(subroutine_combinations) / sizeof(subroutine_combinations[0]); 4512 4513 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 4514 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 4515 { 4516 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 4517 } 4518 4519 /* GL objects */ 4520 Utils::program program(m_context); 4521 Utils::buffer transform_feedback_buffer(m_context); 4522 Utils::vertexArray vao(m_context); 4523 4524 bool result = true; 4525 4526 /* Init GL objects */ 4527 program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names, 4528 n_varyings); 4529 4530 program.use(); 4531 4532 vao.generate(); 4533 vao.bind(); 4534 4535 transform_feedback_buffer.generate(); 4536 4537 /* Get subroutine indices */ 4538 for (GLuint routine = 0; routine < n_subroutine_names; ++routine) 4539 { 4540 m_subroutine_indices[routine] = program.getSubroutineIndex(subroutine_names[routine], GL_VERTEX_SHADER); 4541 } 4542 4543 /* Get subroutine uniform locations */ 4544 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) 4545 { 4546 m_subroutine_uniform_locations[uniform] = 4547 program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); 4548 } 4549 4550 /* Get uniform locations */ 4551 for (GLuint i = 0; i < n_uniform_names; ++i) 4552 { 4553 m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]); 4554 } 4555 4556 /* Test */ 4557 for (GLuint i = 0; i < n_subroutine_combinations; ++i) 4558 { 4559 /* Clean */ 4560 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, 4561 GL_DYNAMIC_COPY); 4562 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); 4563 4564 /* Verify */ 4565 if (false == testDraw(subroutine_combinations[i], uni_left, uni_right, uni_indices)) 4566 { 4567 result = false; 4568 } 4569 } 4570 4571 if (true == result) 4572 { 4573 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 4574 } 4575 else 4576 { 4577 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 4578 } 4579 4580 /* Done */ 4581 return tcu::TestNode::STOP; 4582 } 4583 4584 /* Calculate result of function applied to operands 4585 * 4586 * @param function Function id, 0 is sum, 1 is multiplication 4587 * @param left Left operand 4588 * @param right Right operand 4589 * @param out Function result 4590 **/ 4591 void FunctionalTest7_8::calculate(glw::GLuint function, const Utils::vec4<glw::GLfloat>& left, 4592 const Utils::vec4<glw::GLfloat>& right, Utils::vec4<glw::GLfloat>& out) const 4593 { 4594 if (0 == function) 4595 { 4596 out.m_x = left.m_x + right.m_x; 4597 out.m_y = left.m_y + right.m_y; 4598 out.m_z = left.m_z + right.m_z; 4599 out.m_w = left.m_w + right.m_w; 4600 } 4601 else 4602 { 4603 out.m_x = left.m_x * right.m_x; 4604 out.m_y = left.m_y * right.m_y; 4605 out.m_z = left.m_z * right.m_z; 4606 out.m_w = left.m_w * right.m_w; 4607 } 4608 } 4609 4610 /** Calculate expected values for all operations 4611 * 4612 * @param combination Function combination, first applied function is at index [0] 4613 * @param left Left operand 4614 * @param right Right operand 4615 * @param indices Indices used by dynamic calls 4616 * @param out_combined Expected result of "combined" operation 4617 * @param out_combined_inverted Expected result of "combined_inverted" operation 4618 * @param out_constant Expected result of "constant" operation 4619 * @param out_constant_inverted Expected result of "constant_inverted" operation 4620 * @param out_dynamic Expected result of "dynamic" operation 4621 * @param out_dynamic_inverted Expected result of "out_dynamic_inverted" operation 4622 * @param out_loop Expected result of "loop" operation 4623 **/ 4624 void FunctionalTest7_8::calculate( 4625 const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, const Utils::vec4<glw::GLfloat>& right, 4626 const Utils::vec4<glw::GLuint>& indices, Utils::vec4<glw::GLfloat>& out_combined, 4627 Utils::vec4<glw::GLfloat>& out_combined_inverted, Utils::vec4<glw::GLfloat>& out_constant, 4628 Utils::vec4<glw::GLfloat>& out_constant_inverted, Utils::vec4<glw::GLfloat>& out_dynamic, 4629 Utils::vec4<glw::GLfloat>& out_dynamic_inverted, Utils::vec4<glw::GLfloat>& out_loop) const 4630 { 4631 /* Indices used by "dynamic" operations, range <0..4> */ 4632 const GLuint dynamic_combination[4] = { combination[indices.m_x], combination[indices.m_y], 4633 combination[indices.m_z], combination[indices.m_w] }; 4634 4635 /* Values used by "constant" operations, come from shader code */ 4636 const Utils::vec4<glw::GLfloat> constant_values[] = { Utils::vec4<glw::GLfloat>(1, 2, 3, 4), 4637 Utils::vec4<glw::GLfloat>(-5, -6, -7, -8), 4638 Utils::vec4<glw::GLfloat>(-1, -2, -3, -4), 4639 Utils::vec4<glw::GLfloat>(5, 6, 7, 8), 4640 Utils::vec4<glw::GLfloat>(1, 2, 3, 4) }; 4641 4642 /* Start values */ 4643 Utils::vec4<glw::GLfloat> combined = left; 4644 Utils::vec4<glw::GLfloat> combined_inverted = left; 4645 Utils::vec4<glw::GLfloat> constant = constant_values[0]; 4646 Utils::vec4<glw::GLfloat> constant_inverted = constant_values[0]; 4647 Utils::vec4<glw::GLfloat> dynamic = left; 4648 Utils::vec4<glw::GLfloat> dynamic_inverted = left; 4649 4650 /* Calculate expected results */ 4651 for (GLuint i = 0; i < 4; ++i) 4652 { 4653 GLuint function = combination[i]; 4654 GLuint function_inverted = combination[3 - i]; 4655 GLuint dynamic_function = dynamic_combination[i]; 4656 GLuint dynamic_function_inverted = dynamic_combination[3 - i]; 4657 4658 calculate(function, combined, right, combined); 4659 calculate(function_inverted, combined_inverted, right, combined_inverted); 4660 calculate(function, constant, constant_values[i + 1], constant); 4661 calculate(function_inverted, constant_inverted, constant_values[i + 1], constant_inverted); 4662 calculate(dynamic_function, dynamic, right, dynamic); 4663 calculate(dynamic_function_inverted, dynamic_inverted, right, dynamic_inverted); 4664 } 4665 4666 /* Store results */ 4667 out_combined = combined; 4668 out_combined_inverted = combined_inverted; 4669 out_constant = constant; 4670 out_constant_inverted = constant_inverted; 4671 out_dynamic = dynamic; 4672 out_dynamic_inverted = dynamic_inverted; 4673 out_loop = combined; 4674 } 4675 4676 /** Log error 4677 * 4678 * @param combination Operations combination 4679 * @param left Left operand 4680 * @param right Right operand 4681 * @param indices Inidices used by "dynamic" calls 4682 * @param vec4_expected Expected results 4683 * @param vec4_result Results 4684 * @param array_length Length of array 4685 * @param result Comparison results 4686 **/ 4687 void FunctionalTest7_8::logError(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, 4688 const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices, 4689 const Utils::vec4<glw::GLfloat> vec4_expected[7], 4690 const Utils::vec4<glw::GLfloat> vec4_result[7], glw::GLuint array_length, 4691 bool result[7]) const 4692 { 4693 static const GLuint n_functions = 4; 4694 static const GLuint n_operations = 7; 4695 4696 /* Indices used by "dynamic" operations, range <0..4> */ 4697 const GLuint dynamic_combination[4] = { combination[indices.m_x], combination[indices.m_y], 4698 combination[indices.m_z], combination[indices.m_w] }; 4699 4700 /* Function symbols */ 4701 GLchar functions[4]; 4702 GLchar functions_inverted[4]; 4703 GLchar functions_dynamic[4]; 4704 GLchar functions_dynamic_inverted[4]; 4705 4706 for (GLuint i = 0; i < n_functions; ++i) 4707 { 4708 GLchar function = (0 == combination[i]) ? '+' : '*'; 4709 GLchar dynamic_function = (0 == dynamic_combination[i]) ? '+' : '*'; 4710 4711 functions[i] = function; 4712 functions_inverted[n_functions - i - 1] = function; 4713 functions_dynamic[i] = dynamic_function; 4714 functions_dynamic_inverted[n_functions - i - 1] = dynamic_function; 4715 } 4716 4717 /* Values used by "constant" operations, come from shader code */ 4718 const Utils::vec4<glw::GLfloat> constant_values[] = { Utils::vec4<glw::GLfloat>(1, 2, 3, 4), 4719 Utils::vec4<glw::GLfloat>(-5, -6, -7, -8), 4720 Utils::vec4<glw::GLfloat>(-1, -2, -3, -4), 4721 Utils::vec4<glw::GLfloat>(5, 6, 7, 8), 4722 Utils::vec4<glw::GLfloat>(1, 2, 3, 4) }; 4723 4724 /* Values used by non-"constant" operations */ 4725 Utils::vec4<glw::GLfloat> dynamic_values[5]; 4726 dynamic_values[0] = left; 4727 dynamic_values[1] = right; 4728 dynamic_values[2] = right; 4729 dynamic_values[3] = right; 4730 dynamic_values[4] = right; 4731 4732 /* For each operation */ 4733 for (GLuint i = 0; i < n_operations; ++i) 4734 { 4735 /* If result is failure */ 4736 if (false == result[i]) 4737 { 4738 const GLchar* description = 0; 4739 const Utils::vec4<glw::GLfloat>* input = 0; 4740 const GLchar* operation = 0; 4741 4742 switch (i) 4743 { 4744 case 0: 4745 description = "Call made with predefined array indices"; 4746 input = dynamic_values; 4747 operation = functions; 4748 break; 4749 case 1: 4750 description = "Call made with predefined array indices in inverted order"; 4751 input = dynamic_values; 4752 operation = functions_inverted; 4753 break; 4754 case 2: 4755 description = "Call made with predefined array indices, for constant values"; 4756 input = constant_values; 4757 operation = functions; 4758 break; 4759 case 3: 4760 description = "Call made with predefined array indices in inverted order, for constant values"; 4761 input = constant_values; 4762 operation = functions_inverted; 4763 break; 4764 case 4: 4765 description = "Call made with dynamic array indices"; 4766 input = dynamic_values; 4767 operation = functions_dynamic; 4768 break; 4769 case 5: 4770 description = "Call made with dynamic array indices in inverted order"; 4771 input = dynamic_values; 4772 operation = functions_dynamic_inverted; 4773 break; 4774 case 6: 4775 description = "Call made with loop"; 4776 input = dynamic_values; 4777 operation = functions; 4778 break; 4779 } 4780 4781 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." 4782 << tcu::TestLog::EndMessage; 4783 4784 m_context.getTestContext().getLog() << tcu::TestLog::Message << description << tcu::TestLog::EndMessage; 4785 4786 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4787 4788 message << "Operation: (((("; 4789 input[0].log(message); 4790 for (GLuint function = 0; function < n_functions; ++function) 4791 { 4792 message << " " << operation[function] << " "; 4793 4794 input[function + 1].log(message); 4795 4796 message << ")"; 4797 } 4798 4799 message << tcu::TestLog::EndMessage; 4800 4801 message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4802 4803 message << "Result: "; 4804 vec4_result[i].log(message); 4805 4806 message << tcu::TestLog::EndMessage; 4807 4808 message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 4809 4810 message << "Expected: "; 4811 vec4_expected[i].log(message); 4812 4813 message << tcu::TestLog::EndMessage; 4814 } 4815 4816 /* Check array length, it should be 4 */ 4817 if (4 != array_length) 4818 { 4819 m_context.getTestContext().getLog() << tcu::TestLog::Message 4820 << "Error. Invalid array length: " << array_length << ". Expected 4." 4821 << tcu::TestLog::EndMessage; 4822 } 4823 } 4824 } 4825 4826 /** Execute draw call and verifies captrued varyings 4827 * 4828 * @param combination Function combination, first applied function is at index [0] 4829 * @param left Left operand 4830 * @param right Right operand 4831 * @param indices Indices used by dynamic calls 4832 * 4833 * @return true if all results match expected values, false otherwise 4834 **/ 4835 bool FunctionalTest7_8::testDraw(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, 4836 const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices) const 4837 { 4838 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4839 static const GLuint n_vec4_varyings = 7; 4840 bool result = true; 4841 GLuint subroutine_indices[4]; 4842 static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); 4843 4844 /* Prepare expected results */ 4845 Utils::vec4<glw::GLfloat> expected_results[7]; 4846 calculate(combination, left, right, indices, expected_results[0], expected_results[1], expected_results[2], 4847 expected_results[3], expected_results[4], expected_results[5], expected_results[6]); 4848 4849 /* Set up input data uniforms */ 4850 gl.uniform4f(m_uniform_locations[0], left.m_x, left.m_y, left.m_z, left.m_w); 4851 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 4852 4853 gl.uniform4f(m_uniform_locations[1], right.m_x, right.m_y, right.m_z, right.m_w); 4854 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 4855 4856 gl.uniform4ui(m_uniform_locations[2], indices.m_x, indices.m_y, indices.m_z, indices.m_w); 4857 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4ui"); 4858 4859 /* Prepare subroutine uniform data */ 4860 for (GLuint i = 0; i < n_subroutine_uniforms; ++i) 4861 { 4862 const GLuint location = m_subroutine_uniform_locations[i]; 4863 4864 subroutine_indices[location] = m_subroutine_indices[combination[i]]; 4865 } 4866 4867 /* Set up subroutine uniforms */ 4868 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); 4869 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 4870 4871 /* Execute draw call with transform feedback */ 4872 gl.beginTransformFeedback(GL_POINTS); 4873 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 4874 4875 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 4876 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 4877 4878 gl.endTransformFeedback(); 4879 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 4880 4881 /* Capture results */ 4882 GLvoid* feedback_data = (GLvoid*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 4883 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 4884 4885 Utils::vec4<GLfloat> vec4_results[7]; 4886 bool results[7]; 4887 GLfloat* float_data = (GLfloat*)feedback_data; 4888 for (GLuint i = 0; i < n_vec4_varyings; ++i) 4889 { 4890 vec4_results[i].m_x = float_data[i * 4 + 0]; 4891 vec4_results[i].m_y = float_data[i * 4 + 1]; 4892 vec4_results[i].m_z = float_data[i * 4 + 2]; 4893 vec4_results[i].m_w = float_data[i * 4 + 3]; 4894 } 4895 4896 GLuint* uint_data = (GLuint*)(float_data + (n_vec4_varyings)*4); 4897 GLuint array_length = uint_data[0]; 4898 4899 /* Unmap buffer */ 4900 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 4901 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 4902 4903 /* Verification */ 4904 for (GLuint i = 0; i < n_vec4_varyings; ++i) 4905 { 4906 results[i] = (vec4_results[i] == expected_results[i]); 4907 result = result && results[i]; 4908 } 4909 4910 result = result && (4 == array_length); 4911 4912 /* Log error if any */ 4913 if (false == result) 4914 { 4915 logError(combination, left, right, indices, expected_results, vec4_results, array_length, results); 4916 } 4917 4918 /* Done */ 4919 return result; 4920 } 4921 4922 /** Constructor. 4923 * 4924 * @param context Rendering context. 4925 * 4926 **/ 4927 FunctionalTest9::FunctionalTest9(deqp::Context& context) 4928 : TestCase(context, "subroutines_3_subroutine_types_and_subroutine_uniforms_one_function", 4929 "Makes sure that program with one function associated with 3 different " 4930 "subroutine types and 3 subroutine uniforms using that function compiles " 4931 "and works as expected") 4932 , m_has_test_passed(true) 4933 , m_n_points_to_draw(16) /* arbitrary value */ 4934 , m_po_id(0) 4935 , m_vao_id(0) 4936 , m_vs_id(0) 4937 , m_xfb_bo_id(0) 4938 { 4939 /* Left blank intentionally */ 4940 } 4941 4942 /** De-initializes GL objects that may have been created during test execution. */ 4943 void FunctionalTest9::deinit() 4944 { 4945 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4946 4947 if (m_po_id != 0) 4948 { 4949 gl.deleteProgram(m_po_id); 4950 4951 m_po_id = 0; 4952 } 4953 4954 if (m_vao_id != 0) 4955 { 4956 gl.deleteVertexArrays(1, &m_vao_id); 4957 4958 m_vao_id = 0; 4959 } 4960 4961 if (m_vs_id != 0) 4962 { 4963 gl.deleteShader(m_vs_id); 4964 4965 m_vs_id = 0; 4966 } 4967 4968 if (m_xfb_bo_id != 0) 4969 { 4970 gl.deleteBuffers(1, &m_xfb_bo_id); 4971 4972 m_xfb_bo_id = 0; 4973 } 4974 } 4975 4976 /** Retrieves body of a vertex shader that should be used 4977 * for the testing purposes. 4978 **/ 4979 std::string FunctionalTest9::getVertexShaderBody() const 4980 { 4981 return "#version 400\n" 4982 "\n" 4983 "#extension GL_ARB_shader_subroutine : require\n" 4984 "\n" 4985 "subroutine void subroutineType1(inout float);\n" 4986 "subroutine void subroutineType2(inout float);\n" 4987 "subroutine void subroutineType3(inout float);\n" 4988 "\n" 4989 "subroutine(subroutineType1, subroutineType2, subroutineType3) void function(inout float result)\n" 4990 "{\n" 4991 " result += float(0.123) + float(gl_VertexID);\n" 4992 "}\n" 4993 "\n" 4994 "subroutine uniform subroutineType1 subroutine_uniform1;\n" 4995 "subroutine uniform subroutineType2 subroutine_uniform2;\n" 4996 "subroutine uniform subroutineType3 subroutine_uniform3;\n" 4997 "\n" 4998 "out vec4 result;\n" 4999 "\n" 5000 "void main()\n" 5001 "{\n" 5002 " result = vec4(0, 1, 2, 3);\n" 5003 "\n" 5004 " subroutine_uniform1(result.x);\n" 5005 " subroutine_uniform2(result.y);\n" 5006 " subroutine_uniform3(result.z);\n" 5007 "\n" 5008 " result.w += result.x + result.y + result.z;\n" 5009 "}\n"; 5010 } 5011 5012 /** Initializes all GL objects required to run the test. */ 5013 void FunctionalTest9::initTest() 5014 { 5015 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5016 5017 /* Set up program object */ 5018 const char* xfb_varyings[] = { "result" }; 5019 5020 const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]); 5021 if (!Utils::buildProgram(gl, getVertexShaderBody(), "", /* tc_body */ 5022 "", /* te_body */ 5023 "", /* gs_body */ 5024 "", /* fs_body */ 5025 xfb_varyings, n_xfb_varyings, &m_vs_id, DE_NULL, /* out_tc_id */ 5026 DE_NULL, /* out_te_id */ 5027 DE_NULL, /* out_gs_id */ 5028 DE_NULL, /* out_fs_id */ 5029 &m_po_id)) 5030 { 5031 TCU_FAIL("Program failed to link successfully"); 5032 } 5033 5034 /* Set up a buffer object we will use to hold XFB data */ 5035 const unsigned int xfb_bo_size = static_cast<unsigned int>(sizeof(float) * 4 /* components */ * m_n_points_to_draw); 5036 5037 gl.genBuffers(1, &m_xfb_bo_id); 5038 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 5039 5040 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id); 5041 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); 5042 5043 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id); 5044 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); 5045 5046 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_bo_size, DE_NULL, /* data */ 5047 GL_STATIC_COPY); 5048 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 5049 5050 /* Generate & bind a VAO */ 5051 gl.genVertexArrays(1, &m_vao_id); 5052 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 5053 5054 gl.bindVertexArray(m_vao_id); 5055 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 5056 } 5057 5058 /** Executes test iteration. 5059 * 5060 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 5061 */ 5062 tcu::TestNode::IterateResult FunctionalTest9::iterate() 5063 { 5064 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5065 5066 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 5067 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 5068 { 5069 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 5070 } 5071 initTest(); 5072 5073 /* Issue a draw call to make use of the three subroutine uniforms that we've defined */ 5074 gl.useProgram(m_po_id); 5075 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 5076 5077 gl.beginTransformFeedback(GL_POINTS); 5078 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); 5079 { 5080 gl.drawArrays(GL_POINTS, 0 /* first */, m_n_points_to_draw); 5081 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 5082 } 5083 gl.endTransformFeedback(); 5084 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); 5085 5086 /* Map the XFB BO storage into process space */ 5087 const glw::GLvoid* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 5088 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); 5089 5090 verifyXFBData(xfb_data_ptr); 5091 5092 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 5093 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 5094 5095 /* All done */ 5096 if (m_has_test_passed) 5097 { 5098 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 5099 } 5100 else 5101 { 5102 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 5103 } 5104 5105 return STOP; 5106 } 5107 5108 /** Verifies the data XFBed out by the vertex shader. Should the data 5109 * be found invalid, m_has_test_passed will be set to false. 5110 * 5111 * @param data_ptr XFB data. 5112 **/ 5113 void FunctionalTest9::verifyXFBData(const glw::GLvoid* data_ptr) 5114 { 5115 const float epsilon = 1e-5f; 5116 bool should_continue = true; 5117 const glw::GLfloat* traveller_ptr = (const glw::GLfloat*)data_ptr; 5118 5119 for (unsigned int n_point = 0; n_point < m_n_points_to_draw && should_continue; ++n_point) 5120 { 5121 tcu::Vec4 expected_result(0, 1, 2, 3); 5122 5123 for (unsigned int n_component = 0; n_component < 3 /* xyz */; ++n_component) 5124 { 5125 expected_result[n_component] += 0.123f + float(n_point); 5126 } 5127 5128 expected_result[3 /* w */] += expected_result[0] + expected_result[1] + expected_result[2]; 5129 5130 if (de::abs(expected_result[0] - traveller_ptr[0]) > epsilon || 5131 de::abs(expected_result[1] - traveller_ptr[1]) > epsilon || 5132 de::abs(expected_result[2] - traveller_ptr[2]) > epsilon || 5133 de::abs(expected_result[3] - traveller_ptr[3]) > epsilon) 5134 { 5135 m_testCtx.getLog() << tcu::TestLog::Message << "XFBed data is invalid. Expected:" 5136 "(" 5137 << expected_result[0] << ", " << expected_result[1] << ", " << expected_result[2] << ", " 5138 << expected_result[3] << "), found:(" << traveller_ptr[0] << ", " << traveller_ptr[1] 5139 << ", " << traveller_ptr[2] << ", " << traveller_ptr[3] << ")." 5140 << tcu::TestLog::EndMessage; 5141 5142 m_has_test_passed = false; 5143 should_continue = false; 5144 } 5145 5146 traveller_ptr += 4; /* xyzw */ 5147 } /* for (all rendered points) */ 5148 } 5149 5150 /** Constructor 5151 * 5152 * @param context CTS context 5153 **/ 5154 FunctionalTest10::FunctionalTest10(deqp::Context& context) 5155 : TestCase(context, "arrays_of_arrays_of_uniforms", "Verify that arrays of arrays of uniforms works as expected") 5156 { 5157 } 5158 5159 /** Execute test 5160 * 5161 * @return tcu::TestNode::STOP 5162 **/ 5163 tcu::TestNode::IterateResult FunctionalTest10::iterate() 5164 { 5165 static const GLchar* vertex_shader_code = "#version 400 core\n" 5166 "#extension GL_ARB_arrays_of_arrays : require\n" 5167 "#extension GL_ARB_shader_subroutine : require\n" 5168 "\n" 5169 "precision highp float;\n" 5170 "\n" 5171 "// Subroutine type\n" 5172 "subroutine int routine_type(in int iparam);\n" 5173 "\n" 5174 "// Subroutine definitions\n" 5175 "subroutine(routine_type) int increment(in int iparam)\n" 5176 "{\n" 5177 " return iparam + 1;\n" 5178 "}\n" 5179 "\n" 5180 "subroutine(routine_type) int decrement(in int iparam)\n" 5181 "{\n" 5182 " return iparam - 1;\n" 5183 "}\n" 5184 "\n" 5185 "// Sub routine uniform\n" 5186 "subroutine uniform routine_type routine[4][4];\n" 5187 "\n" 5188 "// Output\n" 5189 "out int out_result;\n" 5190 "\n" 5191 "void main()\n" 5192 "{\n" 5193 " int result = 0;\n" 5194 " \n" 5195 " for (uint j = 0; j < routine.length(); ++j)\n" 5196 " {\n" 5197 " for (uint i = 0; i < routine[j].length(); ++i)\n" 5198 " {\n" 5199 " result = routine[j][i](result);\n" 5200 " }\n" 5201 " }\n" 5202 " \n" 5203 " out_result = result;\n" 5204 "}\n" 5205 "\n"; 5206 5207 static const GLchar* subroutine_names[] = { 5208 "increment", "decrement", 5209 }; 5210 static const GLuint n_subroutine_names = sizeof(subroutine_names) / sizeof(subroutine_names[0]); 5211 5212 static const GLchar* subroutine_uniform_names[] = { 5213 "routine[0][0]", "routine[1][0]", "routine[2][0]", "routine[3][0]", "routine[0][1]", "routine[1][1]", 5214 "routine[2][1]", "routine[3][1]", "routine[0][2]", "routine[1][2]", "routine[2][2]", "routine[3][2]", 5215 "routine[0][3]", "routine[1][3]", "routine[2][3]", "routine[3][3]" 5216 }; 5217 static const GLuint n_subroutine_uniform_names = 5218 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); 5219 5220 static const GLchar* varying_name = "out_result"; 5221 static const GLuint transform_feedback_buffer_size = sizeof(GLint); 5222 5223 static const GLuint configuration_increment[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 5224 5225 static const GLuint configuration_decrement[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; 5226 5227 static const GLuint configuration_mix[16] = { 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1 }; 5228 5229 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 5230 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 5231 { 5232 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 5233 } 5234 5235 /* Do not execute the test if GL_ARB_arrays_of_arrays is not supported */ 5236 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_arrays_of_arrays")) 5237 { 5238 throw tcu::NotSupportedError("GL_ARB_arrays_of_arrays is not supported."); 5239 } 5240 5241 bool result = true; 5242 5243 /* GL objects */ 5244 Utils::program program(m_context); 5245 Utils::buffer transform_feedback_buffer(m_context); 5246 Utils::vertexArray vao(m_context); 5247 5248 /* Init GL objects */ 5249 program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, &varying_name, 5250 1 /* n_varyings */); 5251 5252 program.use(); 5253 5254 vao.generate(); 5255 vao.bind(); 5256 5257 transform_feedback_buffer.generate(); 5258 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, 5259 GL_DYNAMIC_COPY); 5260 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); 5261 5262 /* Get subroutine indices */ 5263 for (GLuint routine = 0; routine < n_subroutine_names; ++routine) 5264 { 5265 m_subroutine_indices[routine] = program.getSubroutineIndex(subroutine_names[routine], GL_VERTEX_SHADER); 5266 } 5267 5268 /* Get subroutine uniform locations */ 5269 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) 5270 { 5271 m_subroutine_uniform_locations[uniform] = 5272 program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); 5273 } 5274 5275 /* Test */ 5276 GLint increment_result = testDraw(configuration_increment); 5277 GLint decrement_result = testDraw(configuration_decrement); 5278 GLint mix_result = testDraw(configuration_mix); 5279 5280 /* Verify */ 5281 if (16 != increment_result) 5282 { 5283 result = false; 5284 } 5285 5286 if (-16 != decrement_result) 5287 { 5288 result = false; 5289 } 5290 if (0 != mix_result) 5291 { 5292 result = false; 5293 } 5294 5295 /* Set test result */ 5296 if (true == result) 5297 { 5298 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 5299 } 5300 else 5301 { 5302 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." 5303 << " Incrementation applied 16 times: " << increment_result 5304 << ". Decrementation applied 16 times: " << decrement_result 5305 << ". Incrementation and decrementation applied 8 times: " << mix_result 5306 << tcu::TestLog::EndMessage; 5307 5308 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 5309 } 5310 5311 /* Done */ 5312 return tcu::TestNode::STOP; 5313 } 5314 5315 /** Execute draw call and return captured varying 5316 * 5317 * @param routine_indices Configuration of subroutine uniforms 5318 * 5319 * @return Value of varying captured with transform feedback 5320 **/ 5321 GLint FunctionalTest10::testDraw(const GLuint routine_indices[16]) const 5322 { 5323 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5324 GLuint subroutine_indices[16]; 5325 static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); 5326 5327 /* Prepare subroutine uniform data */ 5328 for (GLuint i = 0; i < n_subroutine_uniforms; ++i) 5329 { 5330 const GLuint location = m_subroutine_uniform_locations[i]; 5331 5332 subroutine_indices[location] = m_subroutine_indices[routine_indices[i]]; 5333 } 5334 5335 /* Set up subroutine uniforms */ 5336 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); 5337 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 5338 5339 /* Execute draw call with transform feedback */ 5340 gl.beginTransformFeedback(GL_POINTS); 5341 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 5342 5343 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 5344 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 5345 5346 gl.endTransformFeedback(); 5347 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 5348 5349 /* Capture results */ 5350 GLint* feedback_data = (GLint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 5351 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 5352 5353 GLint result = feedback_data[0]; 5354 5355 /* Unmap buffer */ 5356 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 5357 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 5358 5359 return result; 5360 } 5361 5362 /* Definitions of constants used by FunctionalTest11 */ 5363 const GLuint FunctionalTest11::m_texture_height = 32; 5364 const GLuint FunctionalTest11::m_texture_width = 32; 5365 5366 /** Constructor 5367 * 5368 * @param context CTS context 5369 **/ 5370 FunctionalTest11::FunctionalTest11(deqp::Context& context) 5371 : TestCase(context, "globals_sampling_output_discard_function_calls", "Verify that global variables, texture " 5372 "sampling, fragment output, fragment discard " 5373 "and function calls work as expected") 5374 { 5375 } 5376 5377 /** Execute test 5378 * 5379 * @return tcu::TestNode::STOP 5380 **/ 5381 tcu::TestNode::IterateResult FunctionalTest11::iterate() 5382 { 5383 static const GLchar* fragment_shader_code = 5384 "#version 400 core\n" 5385 "#extension GL_ARB_shader_subroutine : require\n" 5386 "\n" 5387 "precision highp float;\n" 5388 "\n" 5389 "// Output\n" 5390 "layout(location = 0) out vec4 out_color;\n" 5391 "\n" 5392 "// Global variables\n" 5393 "vec4 success_color;\n" 5394 "vec4 failure_color;\n" 5395 "\n" 5396 "// Samplers\n" 5397 "uniform sampler2D sampler_1;\n" 5398 "uniform sampler2D sampler_2;\n" 5399 "\n" 5400 "// Functions\n" 5401 "bool are_same(in vec4 left, in vec4 right)\n" 5402 "{\n" 5403 " bvec4 result;\n" 5404 "\n" 5405 " result.x = (left.x == right.x);\n" 5406 " result.y = (left.y == right.y);\n" 5407 " result.z = (left.z == right.z);\n" 5408 " result.w = (left.w == right.w);\n" 5409 "\n" 5410 " return all(result);\n" 5411 "}\n" 5412 "\n" 5413 "bool are_different(in vec4 left, in vec4 right)\n" 5414 "{\n" 5415 " bvec4 result;\n" 5416 "\n" 5417 " result.x = (left.x != right.x);\n" 5418 " result.y = (left.y != right.y);\n" 5419 " result.z = (left.z != right.z);\n" 5420 " result.w = (left.w != right.w);\n" 5421 "\n" 5422 " return any(result);\n" 5423 "}\n" 5424 "\n" 5425 "// Subroutine types\n" 5426 "subroutine void discard_fragment_type(void);\n" 5427 "subroutine void set_global_colors_type(void);\n" 5428 "subroutine vec4 sample_texture_type(in vec2);\n" 5429 "subroutine bool comparison_type(in vec4 left, in vec4 right);\n" 5430 "subroutine void test_type(void);\n" 5431 "\n" 5432 "// Subroutine definitions\n" 5433 "// discard_fragment_type\n" 5434 "subroutine(discard_fragment_type) void discard_yes(void)\n" 5435 "{\n" 5436 " discard;\n" 5437 "}\n" 5438 "\n" 5439 "subroutine(discard_fragment_type) void discard_no(void)\n" 5440 "{\n" 5441 "}\n" 5442 "\n" 5443 "// set_global_colors_type\n" 5444 "subroutine(set_global_colors_type) void red_pass_blue_fail(void)\n" 5445 "{\n" 5446 " success_color = vec4(1, 0, 0, 1);\n" 5447 " failure_color = vec4(0, 0, 1, 1);\n" 5448 "}\n" 5449 "\n" 5450 "subroutine(set_global_colors_type) void blue_pass_red_fail(void)\n" 5451 "{\n" 5452 " success_color = vec4(0, 0, 1, 1);\n" 5453 " failure_color = vec4(1, 0, 0, 1);\n" 5454 "}\n" 5455 "\n" 5456 "// sample_texture_type\n" 5457 "subroutine(sample_texture_type) vec4 first_sampler(in vec2 coord)\n" 5458 "{\n" 5459 " return texture(sampler_1, coord);\n" 5460 "}\n" 5461 "\n" 5462 "subroutine(sample_texture_type) vec4 second_sampler(in vec2 coord)\n" 5463 "{\n" 5464 " return texture(sampler_2, coord);\n" 5465 "}\n" 5466 "\n" 5467 "// comparison_type\n" 5468 "subroutine(comparison_type) bool check_equal(in vec4 left, in vec4 right)\n" 5469 "{\n" 5470 " return are_same(left, right);\n" 5471 "}\n" 5472 "\n" 5473 "subroutine(comparison_type) bool check_not_equal(in vec4 left, in vec4 right)\n" 5474 "{\n" 5475 " return are_different(left, right);\n" 5476 "}\n" 5477 "\n" 5478 "// Subroutine uniforms\n" 5479 "subroutine uniform discard_fragment_type discard_fragment;\n" 5480 "subroutine uniform set_global_colors_type set_global_colors;\n" 5481 "subroutine uniform sample_texture_type sample_texture;\n" 5482 "subroutine uniform comparison_type compare;\n" 5483 "\n" 5484 "// Subroutine definitions\n" 5485 "// test_type\n" 5486 "subroutine(test_type) void test_with_discard(void)\n" 5487 "{\n" 5488 " discard_fragment();" 5489 "\n" 5490 " out_color = failure_color;\n" 5491 "\n" 5492 " set_global_colors();\n" 5493 "\n" 5494 " vec4 sampled_color = sample_texture(gl_PointCoord);\n" 5495 "\n" 5496 " bool comparison_result = compare(success_color, sampled_color);\n" 5497 "\n" 5498 " if (true == comparison_result)\n" 5499 " {\n" 5500 " out_color = success_color;\n" 5501 " }\n" 5502 " else\n" 5503 " {\n" 5504 " out_color = failure_color;\n" 5505 " }\n" 5506 "}\n" 5507 "\n" 5508 "subroutine(test_type) void test_without_discard(void)\n" 5509 "{\n" 5510 " set_global_colors();\n" 5511 "\n" 5512 " vec4 sampled_color = sample_texture(gl_PointCoord);\n" 5513 "\n" 5514 " bool comparison_result = compare(success_color, sampled_color);\n" 5515 "\n" 5516 " if (true == comparison_result)\n" 5517 " {\n" 5518 " out_color = success_color;\n" 5519 " }\n" 5520 " else\n" 5521 " {\n" 5522 " out_color = failure_color;\n" 5523 " }\n" 5524 "}\n" 5525 "\n" 5526 "// Subroutine uniforms\n" 5527 "subroutine uniform test_type test;\n" 5528 "\n" 5529 "void main()\n" 5530 "{\n" 5531 " // Set colors\n" 5532 " success_color = vec4(0.5, 0.5, 0.5, 0.5);\n" 5533 " failure_color = vec4(0.5, 0.5, 0.5, 0.5);\n" 5534 "\n" 5535 " test();\n" 5536 "}\n" 5537 "\n"; 5538 5539 static const GLchar* geometry_shader_code = "#version 400 core\n" 5540 "#extension GL_ARB_shader_subroutine : require\n" 5541 "\n" 5542 "precision highp float;\n" 5543 "\n" 5544 "layout(points) in;\n" 5545 "layout(triangle_strip, max_vertices = 4) out;\n" 5546 "\n" 5547 "void main()\n" 5548 "{\n" 5549 " gl_Position = vec4(-1, -1, 0, 1);\n" 5550 " EmitVertex();\n" 5551 " \n" 5552 " gl_Position = vec4(-1, 1, 0, 1);\n" 5553 " EmitVertex();\n" 5554 " \n" 5555 " gl_Position = vec4( 1, -1, 0, 1);\n" 5556 " EmitVertex();\n" 5557 " \n" 5558 " gl_Position = vec4( 1, 1, 0, 1);\n" 5559 " EmitVertex();\n" 5560 " \n" 5561 " EndPrimitive();\n" 5562 "}\n" 5563 "\n"; 5564 5565 static const GLchar* vertex_shader_code = "#version 400 core\n" 5566 "#extension GL_ARB_shader_subroutine : require\n" 5567 "\n" 5568 "precision highp float;\n" 5569 "\n" 5570 "void main()\n" 5571 "{\n" 5572 "}\n" 5573 "\n"; 5574 5575 static const GLchar* subroutine_names[][2] = { { "discard_yes", "discard_no" }, 5576 { "red_pass_blue_fail", "blue_pass_red_fail" }, 5577 { "first_sampler", "second_sampler" }, 5578 { "check_equal", "check_not_equal" }, 5579 { "test_with_discard", "test_without_discard" } }; 5580 static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]); 5581 5582 static const GLchar* subroutine_uniform_names[] = { "discard_fragment", "set_global_colors", "sample_texture", 5583 "compare", "test" }; 5584 static const GLuint n_subroutine_uniform_names = 5585 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); 5586 5587 static const GLchar* uniform_names[] = { 5588 "sampler_1", "sampler_2", 5589 }; 5590 static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]); 5591 5592 /* Colors */ 5593 static const GLubyte blue_color[4] = { 0, 0, 255, 255 }; 5594 static const GLubyte clean_color[4] = { 0, 0, 0, 0 }; 5595 static const GLubyte red_color[4] = { 255, 0, 0, 255 }; 5596 5597 /* Configurations */ 5598 static const testConfiguration test_configurations[] = { 5599 testConfiguration( 5600 "Expect red color from 1st sampler", red_color, 1 /* discard_fragment : discard_no */, 5601 0 /* set_global_colors : red_pass_blue_fail */, 0 /* sample_texture : first_sampler */, 5602 0 /* compare : check_equal */, 0 /* test : test_with_discard */, 1 /* red */, 5603 0 /* blue */), 5604 5605 testConfiguration( 5606 "Test \"without discard\" option, expect no blue color from 2nd sampler", blue_color, 5607 0 /* discard_fragment : discard_yes */, 1 /* set_global_colors : blue_pass_red_fail */, 5608 1 /* sample_texture : second_sampler */, 1 /* compare : check_not_equal */, 5609 1 /* test : test_without_discard */, 0 /* blue */, 1 /* red */), 5610 5611 testConfiguration("Fragment shoud be discarded", clean_color, 0 /* discard_fragment : discard_yes */, 5612 0 /* set_global_colors : red_pass_blue_fail */, 5613 0 /* sample_texture : first_sampler */, 5614 0 /* compare : check_equal */, 5615 0 /* test : test_with_discard */, 1 /* red */, 0 /* blue */), 5616 5617 testConfiguration( 5618 "Expect blue color from 1st sampler", blue_color, 1 /* discard_fragment : discard_no */, 5619 1 /* set_global_colors : blue_pass_red_fail */, 0 /* sample_texture : first_sampler */, 5620 0 /* compare : check_equal */, 0 /* test : test_with_discard */, 5621 0 /* blue */, 1 /* red */), 5622 5623 testConfiguration( 5624 "Expect red color from 2nd sampler", red_color, 1 /* discard_fragment : discard_no */, 5625 0 /* set_global_colors : red_pass_blue_fail */, 1 /* sample_texture : second_sampler */, 5626 0 /* compare : check_equal */, 0 /* test : test_with_discard */, 5627 0 /* blue */, 1 /* red */), 5628 5629 testConfiguration( 5630 "Expect no blue color from 2nd sampler", blue_color, 1 /* discard_fragment : discard_no */, 5631 1 /* set_global_colors : blue_pass_red_fail */, 1 /* sample_texture : second_sampler */, 5632 1 /* compare : check_not_equal */, 0 /* test : test_with_discard */, 5633 0 /* blue */, 1 /* red */), 5634 }; 5635 static const GLuint n_test_cases = sizeof(test_configurations) / sizeof(test_configurations[0]); 5636 5637 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 5638 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 5639 { 5640 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 5641 } 5642 5643 /* GL objects */ 5644 Utils::texture blue_texture(m_context); 5645 Utils::texture color_texture(m_context); 5646 Utils::framebuffer framebuffer(m_context); 5647 Utils::program program(m_context); 5648 Utils::texture red_texture(m_context); 5649 Utils::vertexArray vao(m_context); 5650 5651 /* Init GL objects */ 5652 program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, 5653 vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); 5654 5655 program.use(); 5656 5657 vao.generate(); 5658 vao.bind(); 5659 5660 blue_texture.create(m_texture_width, m_texture_height, GL_RGBA8); 5661 color_texture.create(m_texture_width, m_texture_height, GL_RGBA8); 5662 red_texture.create(m_texture_width, m_texture_height, GL_RGBA8); 5663 5664 framebuffer.generate(); 5665 framebuffer.bind(); 5666 framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); 5667 5668 /* Get subroutine indices */ 5669 for (GLuint type = 0; type < n_subroutine_types; ++type) 5670 { 5671 m_subroutine_indices[type][0] = program.getSubroutineIndex(subroutine_names[type][0], GL_FRAGMENT_SHADER); 5672 m_subroutine_indices[type][1] = program.getSubroutineIndex(subroutine_names[type][1], GL_FRAGMENT_SHADER); 5673 } 5674 5675 /* Get subroutine uniform locations */ 5676 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) 5677 { 5678 m_subroutine_uniform_locations[uniform] = 5679 program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_FRAGMENT_SHADER); 5680 } 5681 5682 /* Get uniform locations */ 5683 for (GLuint i = 0; i < n_uniform_names; ++i) 5684 { 5685 m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]); 5686 } 5687 5688 /* Prepare textures */ 5689 fillTexture(blue_texture, blue_color); 5690 fillTexture(color_texture, clean_color); 5691 fillTexture(red_texture, red_color); 5692 5693 m_source_textures[0] = blue_texture.m_id; 5694 m_source_textures[1] = red_texture.m_id; 5695 5696 framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 5697 5698 /* Test */ 5699 bool result = true; 5700 for (GLuint i = 0; i < n_test_cases; ++i) 5701 { 5702 /* Clean output texture */ 5703 framebuffer.clear(GL_COLOR_BUFFER_BIT); 5704 5705 /* Execute test */ 5706 if (false == testDraw(test_configurations[i].m_routines, test_configurations[i].m_samplers, 5707 test_configurations[i].m_expected_color, color_texture)) 5708 { 5709 m_context.getTestContext().getLog() 5710 << tcu::TestLog::Message << "Error. Failure for configuration: " << test_configurations[i].m_description 5711 << tcu::TestLog::EndMessage; 5712 5713 result = false; 5714 } 5715 } 5716 5717 /* Set result */ 5718 if (true == result) 5719 { 5720 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 5721 } 5722 else 5723 { 5724 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 5725 } 5726 5727 /* Done */ 5728 return tcu::TestNode::STOP; 5729 } 5730 5731 /** Fill texture with specified color 5732 * 5733 * @param texture Texture instance 5734 * @param color Color 5735 **/ 5736 void FunctionalTest11::fillTexture(Utils::texture& texture, const glw::GLubyte color[4]) const 5737 { 5738 std::vector<GLubyte> texture_data; 5739 5740 /* Prepare texture data */ 5741 texture_data.resize(m_texture_width * m_texture_height * 4); 5742 5743 for (GLuint y = 0; y < m_texture_height; ++y) 5744 { 5745 const GLuint line_offset = y * m_texture_width * 4; 5746 5747 for (GLuint x = 0; x < m_texture_width; ++x) 5748 { 5749 const GLuint point_offset = x * 4 + line_offset; 5750 5751 texture_data[point_offset + 0] = color[0]; /* red */ 5752 texture_data[point_offset + 1] = color[1]; /* green */ 5753 texture_data[point_offset + 2] = color[2]; /* blue */ 5754 texture_data[point_offset + 3] = color[3]; /* alpha */ 5755 } 5756 } 5757 5758 texture.update(m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 5759 } 5760 5761 /** Execute draw call and verify results 5762 * 5763 * @param routine_configuration Configurations of routines to be used 5764 * @param sampler_configuration Configuration of textures to be bound to samplers 5765 * @param expected_color Expected color of result image 5766 * 5767 * @return true if result image is filled with expected color, false otherwise 5768 **/ 5769 bool FunctionalTest11::testDraw(const glw::GLuint routine_configuration[5], const glw::GLuint sampler_configuration[2], 5770 const glw::GLubyte expected_color[4], Utils::texture& color_texture) const 5771 { 5772 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5773 static const GLint n_samplers = 2; 5774 static const GLint n_subroutine_uniforms = 5; 5775 GLuint subroutine_indices[5]; 5776 5777 /* Set samplers */ 5778 for (GLuint i = 0; i < n_samplers; ++i) 5779 { 5780 const GLuint location = m_uniform_locations[i]; 5781 const GLuint texture = m_source_textures[sampler_configuration[i]]; 5782 5783 gl.activeTexture(GL_TEXTURE0 + i); 5784 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 5785 5786 gl.bindTexture(GL_TEXTURE_2D, texture); 5787 GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); 5788 5789 gl.uniform1i(location, i); 5790 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); 5791 } 5792 5793 gl.activeTexture(GL_TEXTURE0 + 0); 5794 5795 /* Set subroutine uniforms */ 5796 for (GLuint i = 0; i < n_subroutine_uniforms; ++i) 5797 { 5798 const GLuint location = m_subroutine_uniform_locations[i]; 5799 const GLuint routine = routine_configuration[i]; 5800 5801 subroutine_indices[location] = m_subroutine_indices[i][routine]; 5802 } 5803 5804 gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 5, subroutine_indices); 5805 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 5806 5807 /* Draw */ 5808 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 5809 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 5810 5811 /* Capture result */ 5812 std::vector<GLubyte> captured_data; 5813 captured_data.resize(m_texture_width * m_texture_height * 4); 5814 5815 color_texture.get(GL_RGBA, GL_UNSIGNED_BYTE, &captured_data[0]); 5816 5817 /* Verify result */ 5818 for (GLuint y = 0; y < m_texture_height; ++y) 5819 { 5820 const GLuint line_offset = y * m_texture_width * 4; 5821 5822 for (GLuint x = 0; x < m_texture_width; ++x) 5823 { 5824 const GLuint point_offset = x * 4 + line_offset; 5825 bool is_as_expected = true; 5826 5827 is_as_expected = is_as_expected && (expected_color[0] == captured_data[point_offset + 0]); /* red */ 5828 is_as_expected = is_as_expected && (expected_color[1] == captured_data[point_offset + 1]); /* green */ 5829 is_as_expected = is_as_expected && (expected_color[2] == captured_data[point_offset + 2]); /* blue */ 5830 is_as_expected = is_as_expected && (expected_color[3] == captured_data[point_offset + 3]); /* alpha */ 5831 5832 if (false == is_as_expected) 5833 { 5834 return false; 5835 } 5836 } 5837 } 5838 5839 /* Done */ 5840 return true; 5841 } 5842 5843 /* Constatns used by FunctionalTest12 */ 5844 const glw::GLuint FunctionalTest12::m_texture_height = 16; 5845 const glw::GLuint FunctionalTest12::m_texture_width = 16; 5846 5847 /** Constructor 5848 * 5849 * @param context CTS context 5850 **/ 5851 FunctionalTest12::FunctionalTest12(deqp::Context& context) 5852 : TestCase(context, "ssbo_atomic_image_load_store", 5853 "Verify that SSBO, atomic counters and image load store work as expected") 5854 , m_left_image(0) 5855 , m_right_image(0) 5856 { 5857 } 5858 5859 /** Execute test 5860 * 5861 * @return tcu::TestNode::STOP 5862 **/ 5863 tcu::TestNode::IterateResult FunctionalTest12::iterate() 5864 { 5865 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 5866 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 5867 { 5868 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 5869 } 5870 5871 bool result = true; 5872 5873 /* Test atomic counters */ 5874 if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_atomic_counters")) 5875 { 5876 if (false == testAtomic()) 5877 { 5878 result = false; 5879 } 5880 } 5881 5882 /* Test shader storage buffer */ 5883 if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_storage_buffer_object")) 5884 { 5885 if (false == testSSBO()) 5886 { 5887 result = false; 5888 } 5889 } 5890 5891 /* Test image load store */ 5892 if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_image_load_store")) 5893 { 5894 if (false == testImage()) 5895 { 5896 result = false; 5897 } 5898 } 5899 5900 /* Set result */ 5901 if (true == result) 5902 { 5903 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 5904 } 5905 else 5906 { 5907 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 5908 } 5909 5910 /* Done */ 5911 return tcu::TestNode::STOP; 5912 } 5913 5914 /** Fill texture with specified color 5915 * 5916 * @param texture Texture instance 5917 * @param color Color 5918 **/ 5919 void FunctionalTest12::fillTexture(Utils::texture& texture, const glw::GLuint color[4]) const 5920 { 5921 std::vector<GLuint> texture_data; 5922 5923 /* Prepare texture data */ 5924 texture_data.resize(m_texture_width * m_texture_height * 4); 5925 5926 for (GLuint y = 0; y < m_texture_height; ++y) 5927 { 5928 const GLuint line_offset = y * m_texture_width * 4; 5929 5930 for (GLuint x = 0; x < m_texture_width; ++x) 5931 { 5932 const GLuint point_offset = x * 4 + line_offset; 5933 5934 texture_data[point_offset + 0] = color[0]; /* red */ 5935 texture_data[point_offset + 1] = color[1]; /* green */ 5936 texture_data[point_offset + 2] = color[2]; /* blue */ 5937 texture_data[point_offset + 3] = color[3]; /* alpha */ 5938 } 5939 } 5940 5941 texture.update(m_texture_width, m_texture_height, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &texture_data[0]); 5942 } 5943 5944 /** Test atomic counters 5945 * 5946 * @return true if test pass, false otherwise 5947 **/ 5948 bool FunctionalTest12::testAtomic() 5949 { 5950 static const GLchar* fragment_shader_code = "#version 400 core\n" 5951 "#extension GL_ARB_shader_atomic_counters : require\n" 5952 "#extension GL_ARB_shader_subroutine : require\n" 5953 "\n" 5954 "precision highp float;\n" 5955 "\n" 5956 "layout(location = 0) out uint out_color;\n" 5957 "\n" 5958 "layout(binding = 0, offset = 8) uniform atomic_uint one;\n" 5959 "layout(binding = 0, offset = 4) uniform atomic_uint two;\n" 5960 "layout(binding = 0, offset = 0) uniform atomic_uint three;\n" 5961 "\n" 5962 "subroutine void atomic_routine(void)\n;" 5963 "\n" 5964 "subroutine(atomic_routine) void increment_two(void)\n" 5965 "{\n" 5966 " out_color = atomicCounterIncrement(two);\n" 5967 "}\n" 5968 "\n" 5969 "subroutine(atomic_routine) void decrement_three(void)\n" 5970 "{\n" 5971 " out_color = atomicCounterDecrement(three);\n" 5972 "}\n" 5973 "\n" 5974 "subroutine(atomic_routine) void read_one(void)\n" 5975 "{\n" 5976 " out_color = atomicCounter(one);\n" 5977 "}\n" 5978 "\n" 5979 "subroutine uniform atomic_routine routine;\n" 5980 "\n" 5981 "void main()\n" 5982 "{\n" 5983 " routine();\n" 5984 "}\n" 5985 "\n"; 5986 5987 static const GLchar* geometry_shader_code = "#version 400 core\n" 5988 "#extension GL_ARB_shader_subroutine : require\n" 5989 "\n" 5990 "precision highp float;\n" 5991 "\n" 5992 "layout(points) in;\n" 5993 "layout(triangle_strip, max_vertices = 4) out;\n" 5994 "\n" 5995 "void main()\n" 5996 "{\n" 5997 " gl_Position = vec4(-1, -1, 0, 1);\n" 5998 " EmitVertex();\n" 5999 " \n" 6000 " gl_Position = vec4(-1, 1, 0, 1);\n" 6001 " EmitVertex();\n" 6002 " \n" 6003 " gl_Position = vec4( 1, -1, 0, 1);\n" 6004 " EmitVertex();\n" 6005 " \n" 6006 " gl_Position = vec4( 1, 1, 0, 1);\n" 6007 " EmitVertex();\n" 6008 " \n" 6009 " EndPrimitive();\n" 6010 "}\n" 6011 "\n"; 6012 6013 static const GLchar* vertex_shader_code = "#version 400 core\n" 6014 "#extension GL_ARB_shader_subroutine : require\n" 6015 "\n" 6016 "precision highp float;\n" 6017 "\n" 6018 "void main()\n" 6019 "{\n" 6020 "}\n" 6021 "\n"; 6022 6023 static const GLchar* subroutine_names[] = { "increment_two", "decrement_three", "read_one" }; 6024 6025 /* Test data */ 6026 static const glw::GLuint atomic_buffer_data[] = { m_texture_width * m_texture_height, 6027 m_texture_width * m_texture_height, 6028 m_texture_width * m_texture_height }; 6029 6030 static const glw::GLuint expected_incremented_two[] = { atomic_buffer_data[0], 2 * atomic_buffer_data[1], 6031 atomic_buffer_data[2] }; 6032 6033 static const glw::GLuint expected_decremented_three[] = { 0, expected_incremented_two[1], 6034 expected_incremented_two[2] }; 6035 6036 static const glw::GLuint expected_read_one[] = { expected_decremented_three[0], expected_decremented_three[1], 6037 expected_decremented_three[2] }; 6038 6039 /* GL objects */ 6040 Utils::buffer atomic_buffer(m_context); 6041 Utils::texture color_texture(m_context); 6042 Utils::framebuffer framebuffer(m_context); 6043 Utils::program program(m_context); 6044 Utils::vertexArray vao(m_context); 6045 6046 /* Init GL objects */ 6047 program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, 6048 vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); 6049 6050 program.use(); 6051 6052 vao.generate(); 6053 vao.bind(); 6054 6055 color_texture.create(m_texture_width, m_texture_height, GL_R32UI); 6056 6057 atomic_buffer.generate(); 6058 atomic_buffer.update(GL_ATOMIC_COUNTER_BUFFER, sizeof(atomic_buffer_data), (GLvoid*)atomic_buffer_data, 6059 GL_STATIC_DRAW); 6060 atomic_buffer.bindRange(GL_ATOMIC_COUNTER_BUFFER, 0 /* index */, 0 /* offset */, sizeof(atomic_buffer_data)); 6061 6062 framebuffer.generate(); 6063 framebuffer.bind(); 6064 framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); 6065 framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 6066 framebuffer.clear(GL_COLOR_BUFFER_BIT); 6067 6068 /* Subroutine indices */ 6069 GLuint increment_two = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER); 6070 GLuint decrement_three = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER); 6071 GLuint read_one = program.getSubroutineIndex(subroutine_names[2], GL_FRAGMENT_SHADER); 6072 6073 /* Test */ 6074 bool result = true; 6075 6076 if (false == testAtomicDraw(increment_two, expected_incremented_two)) 6077 { 6078 result = false; 6079 } 6080 6081 if (false == testAtomicDraw(decrement_three, expected_decremented_three)) 6082 { 6083 result = false; 6084 } 6085 6086 if (false == testAtomicDraw(read_one, expected_read_one)) 6087 { 6088 result = false; 6089 } 6090 6091 /* Done */ 6092 return result; 6093 } 6094 6095 /** Execture draw call and verify results 6096 * 6097 * @param subroutine_index Index of subroutine that shall be used during draw call 6098 * @param expected_results Expected results 6099 * 6100 * @return true if results are as expected, false otherwise 6101 **/ 6102 bool FunctionalTest12::testAtomicDraw(GLuint subroutine_index, const GLuint expected_results[3]) const 6103 { 6104 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 6105 6106 /* Set subroutine uniforms */ 6107 gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index); 6108 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 6109 6110 /* Draw */ 6111 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 6112 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 6113 6114 /* Capture results */ 6115 GLuint* atomic_results = (GLuint*)gl.mapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_READ_ONLY); 6116 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 6117 6118 /* Verify */ 6119 bool result = (0 == memcmp(expected_results, atomic_results, 3 * sizeof(GLuint))); 6120 6121 if (false == result) 6122 { 6123 m_context.getTestContext().getLog() 6124 << tcu::TestLog::Message << "Error. Invalid result. " 6125 << "Result: [ " << atomic_results[0] << ", " << atomic_results[1] << ", " << atomic_results[2] << " ] " 6126 << "Expected: [ " << expected_results[0] << ", " << expected_results[1] << ", " << expected_results[2] 6127 << " ]" << tcu::TestLog::EndMessage; 6128 } 6129 6130 /* Unmap buffer */ 6131 gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER); 6132 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 6133 6134 /* Done */ 6135 return result; 6136 } 6137 6138 /** Test image load store 6139 * 6140 * @return true if test pass, false otherwise 6141 **/ 6142 bool FunctionalTest12::testImage() 6143 { 6144 static const GLchar* fragment_shader_code = 6145 "#version 400 core\n" 6146 "#extension GL_ARB_shader_image_load_store : require\n" 6147 "#extension GL_ARB_shader_subroutine : require\n" 6148 "\n" 6149 "precision highp float;\n" 6150 "\n" 6151 "layout(location = 0) out uvec4 out_color;\n" 6152 "\n" 6153 "layout(rgba32ui) uniform uimage2D left_image;\n" 6154 "layout(rgba32ui) uniform uimage2D right_image;\n" 6155 "\n" 6156 "subroutine void image_routine(void);\n" 6157 "\n" 6158 "subroutine(image_routine) void left_to_right(void)\n" 6159 "{\n" 6160 " out_color = imageLoad (left_image, ivec2(gl_FragCoord.xy));\n" 6161 " imageStore(right_image, ivec2(gl_FragCoord.xy), out_color);\n" 6162 "}\n" 6163 "\n" 6164 "subroutine(image_routine) void right_to_left(void)\n" 6165 "{\n" 6166 " out_color = imageLoad (right_image, ivec2(gl_FragCoord.xy));\n" 6167 " imageStore(left_image, ivec2(gl_FragCoord.xy), out_color);\n" 6168 "}\n" 6169 "\n" 6170 "subroutine uniform image_routine routine;\n" 6171 "\n" 6172 "void main()\n" 6173 "{\n" 6174 " routine();\n" 6175 "}\n" 6176 "\n"; 6177 6178 static const GLchar* geometry_shader_code = "#version 400 core\n" 6179 "#extension GL_ARB_shader_subroutine : require\n" 6180 "\n" 6181 "precision highp float;\n" 6182 "\n" 6183 "layout(points) in;\n" 6184 "layout(triangle_strip, max_vertices = 4) out;\n" 6185 "\n" 6186 "void main()\n" 6187 "{\n" 6188 " gl_Position = vec4(-1, -1, 0, 1);\n" 6189 " EmitVertex();\n" 6190 " \n" 6191 " gl_Position = vec4(-1, 1, 0, 1);\n" 6192 " EmitVertex();\n" 6193 " \n" 6194 " gl_Position = vec4( 1, -1, 0, 1);\n" 6195 " EmitVertex();\n" 6196 " \n" 6197 " gl_Position = vec4( 1, 1, 0, 1);\n" 6198 " EmitVertex();\n" 6199 " \n" 6200 " EndPrimitive();\n" 6201 "}\n" 6202 "\n"; 6203 6204 static const GLchar* vertex_shader_code = "#version 400 core\n" 6205 "#extension GL_ARB_shader_subroutine : require\n" 6206 "\n" 6207 "precision highp float;\n" 6208 "\n" 6209 "void main()\n" 6210 "{\n" 6211 "}\n" 6212 "\n"; 6213 6214 static const GLchar* subroutine_names[] = { "left_to_right", "right_to_left" }; 6215 6216 static const GLchar* uniform_names[] = { "left_image", "right_image" }; 6217 6218 /* Test data */ 6219 static const GLuint blue_color[4] = { 0, 0, 255, 255 }; 6220 static const GLuint clean_color[4] = { 16, 32, 64, 128 }; 6221 static const GLuint red_color[4] = { 255, 0, 0, 255 }; 6222 6223 /* GL objects */ 6224 Utils::texture blue_texture(m_context); 6225 Utils::texture destination_texture(m_context); 6226 Utils::texture color_texture(m_context); 6227 Utils::framebuffer framebuffer(m_context); 6228 Utils::program program(m_context); 6229 Utils::texture red_texture(m_context); 6230 Utils::vertexArray vao(m_context); 6231 6232 /* Init GL objects */ 6233 program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, 6234 vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); 6235 6236 program.use(); 6237 6238 vao.generate(); 6239 vao.bind(); 6240 6241 blue_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); 6242 destination_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); 6243 color_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); 6244 red_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); 6245 6246 fillTexture(blue_texture, blue_color); 6247 fillTexture(destination_texture, clean_color); 6248 fillTexture(red_texture, red_color); 6249 6250 framebuffer.generate(); 6251 framebuffer.bind(); 6252 framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); 6253 framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 6254 framebuffer.clear(GL_COLOR_BUFFER_BIT); 6255 6256 /* Subroutine indices */ 6257 GLuint left_to_right = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER); 6258 GLuint right_to_left = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER); 6259 6260 /* Uniform locations */ 6261 m_left_image = program.getUniformLocation(uniform_names[0]); 6262 m_right_image = program.getUniformLocation(uniform_names[1]); 6263 6264 /* Test */ 6265 bool result = true; 6266 6267 if (false == testImageDraw(left_to_right, blue_texture, destination_texture, blue_color, blue_color)) 6268 { 6269 result = false; 6270 } 6271 6272 if (false == testImageDraw(left_to_right, red_texture, destination_texture, red_color, red_color)) 6273 { 6274 result = false; 6275 } 6276 6277 if (false == testImageDraw(right_to_left, destination_texture, blue_texture, blue_color, blue_color)) 6278 { 6279 result = false; 6280 } 6281 6282 if (false == testImageDraw(right_to_left, destination_texture, red_texture, red_color, red_color)) 6283 { 6284 result = false; 6285 } 6286 6287 if (false == testImageDraw(left_to_right, blue_texture, red_texture, blue_color, blue_color)) 6288 { 6289 result = false; 6290 } 6291 6292 /* Done */ 6293 return result; 6294 } 6295 6296 /** Execute draw call and verifies results 6297 * 6298 * @param subroutine_index Index of subroutine that shall be used during draw call 6299 * @param left "Left" texture 6300 * @param right "Right" texture 6301 * @param expected_left_color Expected color of "left" texture 6302 * @param expected_right_color Expected color of "right" texture 6303 * 6304 * @return true if verification result is positive, false otherwise 6305 **/ 6306 bool FunctionalTest12::testImageDraw(GLuint subroutine_index, Utils::texture& left, Utils::texture& right, 6307 const GLuint expected_left_color[4], const GLuint expected_right_color[4]) const 6308 { 6309 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 6310 6311 /* Set subroutine uniforms */ 6312 gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index); 6313 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 6314 6315 /* Set up image units */ 6316 gl.uniform1i(m_left_image, 0); 6317 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); 6318 6319 gl.uniform1i(m_right_image, 1); 6320 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); 6321 6322 gl.bindImageTexture(0, left.m_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI); 6323 GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); 6324 6325 gl.bindImageTexture(1, right.m_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI); 6326 GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); 6327 6328 /* Draw */ 6329 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 6330 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 6331 6332 /* Verify results */ 6333 bool result = true; 6334 6335 if (false == verifyTexture(left, expected_left_color)) 6336 { 6337 m_context.getTestContext().getLog() << tcu::TestLog::Message 6338 << "Error. Invalid result. Left texture is filled with wrong color." 6339 << tcu::TestLog::EndMessage; 6340 result = false; 6341 } 6342 6343 if (false == verifyTexture(right, expected_right_color)) 6344 { 6345 m_context.getTestContext().getLog() << tcu::TestLog::Message 6346 << "Error. Invalid result. Right texture is filled with wrong color." 6347 << tcu::TestLog::EndMessage; 6348 result = false; 6349 } 6350 6351 /* Done */ 6352 return result; 6353 } 6354 6355 /** Test shader storage buffer 6356 * 6357 * @return true if test pass, false otherwise 6358 **/ 6359 bool FunctionalTest12::testSSBO() 6360 { 6361 static const GLchar* fragment_shader_code = "#version 400 core\n" 6362 "#extension GL_ARB_shader_storage_buffer_object : require\n" 6363 "#extension GL_ARB_shader_subroutine : require\n" 6364 "\n" 6365 "precision highp float;\n" 6366 "\n" 6367 "layout(location = 0) out uvec4 out_color;\n" 6368 "\n" 6369 "layout(std140, binding = 0) buffer Buffer\n" 6370 "{\n" 6371 " uvec4 entry;\n" 6372 "};\n" 6373 "\n" 6374 "subroutine void ssbo_routine(void)\n;" 6375 "\n" 6376 "subroutine(ssbo_routine) void increment(void)\n" 6377 "{\n" 6378 " out_color.x = atomicAdd(entry.x, 1);\n" 6379 " out_color.y = atomicAdd(entry.y, 1);\n" 6380 " out_color.z = atomicAdd(entry.z, 1);\n" 6381 " out_color.w = atomicAdd(entry.w, 1);\n" 6382 "}\n" 6383 "\n" 6384 "subroutine(ssbo_routine) void decrement(void)\n" 6385 "{\n" 6386 " out_color.x = atomicAdd(entry.x, -1);\n" 6387 " out_color.y = atomicAdd(entry.y, -1);\n" 6388 " out_color.z = atomicAdd(entry.z, -1);\n" 6389 " out_color.w = atomicAdd(entry.w, -1);\n" 6390 "}\n" 6391 "\n" 6392 "subroutine uniform ssbo_routine routine;\n" 6393 "\n" 6394 "void main()\n" 6395 "{\n" 6396 " routine();\n" 6397 "}\n" 6398 "\n"; 6399 6400 static const GLchar* geometry_shader_code = "#version 400 core\n" 6401 "#extension GL_ARB_shader_subroutine : require\n" 6402 "\n" 6403 "precision highp float;\n" 6404 "\n" 6405 "layout(points) in;\n" 6406 "layout(triangle_strip, max_vertices = 4) out;\n" 6407 "\n" 6408 "void main()\n" 6409 "{\n" 6410 " gl_Position = vec4(-1, -1, 0, 1);\n" 6411 " EmitVertex();\n" 6412 " \n" 6413 " gl_Position = vec4(-1, 1, 0, 1);\n" 6414 " EmitVertex();\n" 6415 " \n" 6416 " gl_Position = vec4( 1, -1, 0, 1);\n" 6417 " EmitVertex();\n" 6418 " \n" 6419 " gl_Position = vec4( 1, 1, 0, 1);\n" 6420 " EmitVertex();\n" 6421 " \n" 6422 " EndPrimitive();\n" 6423 "}\n" 6424 "\n"; 6425 6426 static const GLchar* vertex_shader_code = "#version 400 core\n" 6427 "#extension GL_ARB_shader_subroutine : require\n" 6428 "\n" 6429 "precision highp float;\n" 6430 "\n" 6431 "void main()\n" 6432 "{\n" 6433 "}\n" 6434 "\n"; 6435 6436 static const GLchar* subroutine_names[] = { "increment", "decrement" }; 6437 6438 /* Test data */ 6439 static const glw::GLuint buffer_data[] = { m_texture_width * m_texture_height + 1, 6440 m_texture_width * m_texture_height + 2, 6441 m_texture_width * m_texture_height + 3, 6442 m_texture_width * m_texture_height + 4 }; 6443 6444 static const glw::GLuint expected_incremented[] = { m_texture_width * m_texture_height + buffer_data[0], 6445 m_texture_width * m_texture_height + buffer_data[1], 6446 m_texture_width * m_texture_height + buffer_data[2], 6447 m_texture_width * m_texture_height + buffer_data[3] }; 6448 6449 static const glw::GLuint expected_decremented[] = { buffer_data[0], buffer_data[1], buffer_data[2], 6450 buffer_data[3] }; 6451 6452 /* GL objects */ 6453 Utils::buffer buffer(m_context); 6454 Utils::texture color_texture(m_context); 6455 Utils::framebuffer framebuffer(m_context); 6456 Utils::program program(m_context); 6457 Utils::vertexArray vao(m_context); 6458 6459 /* Init GL objects */ 6460 program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, 6461 vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); 6462 6463 program.use(); 6464 6465 vao.generate(); 6466 vao.bind(); 6467 6468 color_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); 6469 6470 buffer.generate(); 6471 buffer.update(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), (GLvoid*)buffer_data, GL_STATIC_DRAW); 6472 buffer.bindRange(GL_SHADER_STORAGE_BUFFER, 0 /* index */, 0 /* offset */, sizeof(buffer_data)); 6473 6474 framebuffer.generate(); 6475 framebuffer.bind(); 6476 framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); 6477 framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 6478 framebuffer.clear(GL_COLOR_BUFFER_BIT); 6479 6480 /* Subroutine indices */ 6481 GLuint increment = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER); 6482 GLuint decrement = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER); 6483 6484 /* Test */ 6485 bool result = true; 6486 6487 if (false == testSSBODraw(increment, expected_incremented)) 6488 { 6489 result = false; 6490 } 6491 6492 if (false == testSSBODraw(decrement, expected_decremented)) 6493 { 6494 result = false; 6495 } 6496 6497 /* Done */ 6498 return result; 6499 } 6500 6501 /** Execute draw call and verify results 6502 * 6503 * @param subroutine_index Index of subroutine that shall be used by draw call 6504 * @param expected_results Expected results 6505 * 6506 * 6507 **/ 6508 bool FunctionalTest12::testSSBODraw(GLuint subroutine_index, const GLuint expected_results[4]) const 6509 { 6510 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 6511 6512 /* Set subroutine uniforms */ 6513 gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index); 6514 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 6515 6516 /* Draw */ 6517 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 6518 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 6519 6520 /* Capture results */ 6521 GLuint* ssbo_results = (GLuint*)gl.mapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY); 6522 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 6523 6524 /* Verify */ 6525 bool result = (0 == memcmp(expected_results, ssbo_results, 4 * sizeof(GLuint))); 6526 6527 if (false == result) 6528 { 6529 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result. " 6530 << "Result: [ " << ssbo_results[0] << ", " << ssbo_results[1] << ", " 6531 << ssbo_results[2] << ", " << ssbo_results[3] << " ] " 6532 << "Expected: [ " << expected_results[0] << ", " << expected_results[1] 6533 << ", " << expected_results[2] << ", " << expected_results[3] << " ]" 6534 << tcu::TestLog::EndMessage; 6535 } 6536 6537 /* Unmap buffer */ 6538 gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); 6539 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 6540 6541 /* Done */ 6542 return result; 6543 } 6544 6545 /** Check if texture is filled with expected color 6546 * 6547 * @param texture Texture instance 6548 * @param expected_color Expected color 6549 * 6550 * @return true if texture is filled with specified color, false otherwise 6551 **/ 6552 bool FunctionalTest12::verifyTexture(Utils::texture& texture, const GLuint expected_color[4]) const 6553 { 6554 std::vector<GLuint> results; 6555 results.resize(m_texture_width * m_texture_height * 4); 6556 6557 texture.get(GL_RGBA_INTEGER, GL_UNSIGNED_INT, &results[0]); 6558 6559 for (GLuint y = 0; y < m_texture_height; ++y) 6560 { 6561 const GLuint line_offset = y * m_texture_width * 4; 6562 6563 for (GLuint x = 0; x < m_texture_width; ++x) 6564 { 6565 const GLuint point_offset = line_offset + x * 4; 6566 bool result = true; 6567 6568 result = result && (results[point_offset + 0] == expected_color[0]); 6569 result = result && (results[point_offset + 1] == expected_color[1]); 6570 result = result && (results[point_offset + 2] == expected_color[2]); 6571 result = result && (results[point_offset + 3] == expected_color[3]); 6572 6573 if (false == result) 6574 { 6575 return false; 6576 } 6577 } 6578 } 6579 6580 return true; 6581 } 6582 6583 /** Constructor. 6584 * 6585 * @param context Rendering context. 6586 * 6587 **/ 6588 FunctionalTest13::FunctionalTest13(deqp::Context& context) 6589 : TestCase(context, "subroutines_with_separate_shader_objects", 6590 "Verifies that subroutines work correctly when used in separate " 6591 "shader objects") 6592 , m_fbo_id(0) 6593 , m_pipeline_id(0) 6594 , m_read_buffer(DE_NULL) 6595 , m_to_height(4) 6596 , m_to_id(0) 6597 , m_to_width(4) 6598 , m_vao_id(0) 6599 , m_has_test_passed(true) 6600 { 6601 memset(m_fs_po_ids, 0, sizeof(m_fs_po_ids)); 6602 memset(m_gs_po_ids, 0, sizeof(m_gs_po_ids)); 6603 memset(m_tc_po_ids, 0, sizeof(m_tc_po_ids)); 6604 memset(m_te_po_ids, 0, sizeof(m_te_po_ids)); 6605 memset(m_vs_po_ids, 0, sizeof(m_vs_po_ids)); 6606 } 6607 6608 /** Deinitializes all GL objects that may have been created during test 6609 * execution, as well as releases all process-side buffers that may have 6610 * been allocated during the process. 6611 * The function also restores default GL state configuration. 6612 **/ 6613 void FunctionalTest13::deinit() 6614 { 6615 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 6616 6617 if (m_fbo_id != 0) 6618 { 6619 gl.deleteFramebuffers(1, &m_fbo_id); 6620 6621 m_fbo_id = 0; 6622 } 6623 6624 if (m_pipeline_id != 0) 6625 { 6626 gl.deleteProgramPipelines(1, &m_pipeline_id); 6627 6628 m_pipeline_id = 0; 6629 } 6630 6631 if (m_read_buffer != DE_NULL) 6632 { 6633 delete[] m_read_buffer; 6634 6635 m_read_buffer = DE_NULL; 6636 } 6637 6638 for (unsigned int n_id = 0; n_id < 2 /* po id variants */; ++n_id) 6639 { 6640 if (m_fs_po_ids[n_id] != 0) 6641 { 6642 gl.deleteProgram(m_fs_po_ids[n_id]); 6643 6644 m_fs_po_ids[n_id] = 0; 6645 } 6646 6647 if (m_gs_po_ids[n_id] != 0) 6648 { 6649 gl.deleteProgram(m_gs_po_ids[n_id]); 6650 6651 m_gs_po_ids[n_id] = 0; 6652 } 6653 6654 if (m_tc_po_ids[n_id] != 0) 6655 { 6656 gl.deleteProgram(m_tc_po_ids[n_id]); 6657 6658 m_tc_po_ids[n_id] = 0; 6659 } 6660 6661 if (m_te_po_ids[n_id] != 0) 6662 { 6663 gl.deleteProgram(m_te_po_ids[n_id]); 6664 6665 m_te_po_ids[n_id] = 0; 6666 } 6667 6668 if (m_vs_po_ids[n_id] != 0) 6669 { 6670 gl.deleteProgram(m_vs_po_ids[n_id]); 6671 6672 m_vs_po_ids[n_id] = 0; 6673 } 6674 } /* for (both shader program object variants) */ 6675 6676 if (m_to_id != 0) 6677 { 6678 gl.deleteTextures(1, &m_to_id); 6679 6680 m_to_id = 0; 6681 } 6682 6683 if (m_vao_id != 0) 6684 { 6685 gl.deleteVertexArrays(1, &m_vao_id); 6686 6687 m_vao_id = 0; 6688 } 6689 6690 /* Restore default GL_PATCH_VERTICES setting value */ 6691 gl.patchParameteri(GL_PATCH_VERTICES, 3); 6692 6693 /* Restore default GL_PACK_ALIGNMENT setting value */ 6694 gl.pixelStorei(GL_PACK_ALIGNMENT, 4); 6695 } 6696 6697 /** Retrieves body of a fragment shader that should be used for the test. 6698 * The subroutine implementations are slightly changed, depending on the 6699 * index of the shader, as specified by the caller. 6700 * 6701 * @param n_id Index of the shader. 6702 * 6703 * @return Requested string. 6704 **/ 6705 std::string FunctionalTest13::getFragmentShaderBody(unsigned int n_id) 6706 { 6707 std::stringstream result_sstream; 6708 6709 /* Pre-amble */ 6710 result_sstream << "#version 400\n" 6711 "\n" 6712 "#extension GL_ARB_shader_subroutine : require\n" 6713 "\n" 6714 /* Sub-routine */ 6715 "subroutine void SubroutineFSType(inout vec4 result);\n" 6716 "\n" 6717 "subroutine(SubroutineFSType) void SubroutineFS1(inout vec4 result)\n" 6718 "{\n" 6719 " result += vec4(" 6720 << float(n_id + 1) / 10.0f << ", " << float(n_id + 2) / 10.0f << ", " << float(n_id + 3) / 10.0f 6721 << ", " << float(n_id + 4) / 10.0f 6722 << ");\n" 6723 "}\n" 6724 "subroutine(SubroutineFSType) void SubroutineFS2(inout vec4 result)\n" 6725 "{\n" 6726 " result += vec4(" 6727 << float(n_id + 1) / 20.0f << ", " << float(n_id + 2) / 20.0f << ", " << float(n_id + 3) / 20.0f 6728 << ", " << float(n_id + 4) / 20.0f << ");\n" 6729 "}\n" 6730 "\n" 6731 "subroutine uniform SubroutineFSType function;\n" 6732 "\n" 6733 /* Input block */ 6734 "in GS_DATA\n" 6735 "{\n" 6736 " vec4 data;\n" 6737 "} in_gs;\n" 6738 "\n" 6739 "out vec4 result;\n" 6740 /* main() declaration */ 6741 "void main()\n" 6742 "{\n" 6743 " vec4 data = in_gs.data;\n" 6744 " function(data);\n" 6745 "\n" 6746 " result = data;\n" 6747 "}\n"; 6748 6749 return result_sstream.str(); 6750 } 6751 6752 /** Retrieves body of a geometry shader that should be used for the test. 6753 * The subroutine implementations are slightly changed, depending on the 6754 * index of the shader, as specified by the caller. 6755 * 6756 * @param n_id Index of the shader. 6757 * 6758 * @return Requested string. 6759 **/ 6760 std::string FunctionalTest13::getGeometryShaderBody(unsigned int n_id) 6761 { 6762 std::stringstream result_sstream; 6763 6764 /* Pre-amble */ 6765 result_sstream << "#version 400\n" 6766 "\n" 6767 "#extension GL_ARB_shader_subroutine : require\n" 6768 "\n" 6769 "layout(points) in;\n" 6770 "layout(triangle_strip, max_vertices = 4) out;\n" 6771 /* Sub-routine */ 6772 "subroutine void SubroutineGSType(inout vec4 result);\n" 6773 "\n" 6774 "subroutine(SubroutineGSType) void SubroutineGS1(inout vec4 result)\n" 6775 "{\n" 6776 " result += vec4(0, 0, 0, " 6777 << float(n_id + 1) * 0.425f << ");\n" 6778 "}\n" 6779 "subroutine(SubroutineGSType) void SubroutineGS2(inout vec4 result)\n" 6780 "{\n" 6781 " result += vec4(0, 0, 0, " 6782 << float(n_id + 1) * 0.0425f << ");\n" 6783 "}\n" 6784 "\n" 6785 "subroutine uniform SubroutineGSType function;\n" 6786 "\n" 6787 /* Input block */ 6788 "in TE_DATA\n" 6789 "{\n" 6790 " vec4 data;\n" 6791 "} in_te[];\n" 6792 "\n" 6793 /* Output block */ 6794 "out GS_DATA\n" 6795 "{\n" 6796 " vec4 data;\n" 6797 "} out_gs;\n" 6798 "\n" 6799 "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" 6800 "out gl_PerVertex { vec4 gl_Position; };\n" 6801 /* main() declaration */ 6802 "void main()\n" 6803 "{\n" 6804 " vec4 data = in_te[0].data;\n" 6805 "\n" 6806 " function(data);\n" 6807 "\n" 6808 " gl_Position = vec4(1, -1, 0, 1);\n" 6809 " out_gs.data = data;\n" 6810 " EmitVertex();\n" 6811 "\n" 6812 " gl_Position = vec4(-1, -1, 0, 1);\n" 6813 " out_gs.data = data;\n" 6814 " EmitVertex();\n" 6815 "\n" 6816 " gl_Position = vec4(1, 1, 0, 1);\n" 6817 " out_gs.data = data;\n" 6818 " EmitVertex();\n" 6819 "\n" 6820 " gl_Position = vec4(-1, 1, 0, 1);\n" 6821 " out_gs.data = data;\n" 6822 " EmitVertex();\n" 6823 " EndPrimitive();\n" 6824 "}\n"; 6825 6826 return result_sstream.str(); 6827 } 6828 6829 /** Retrieves body of a tessellation control shader that should be used for the test. 6830 * The subroutine implementations are slightly changed, depending on the 6831 * index of the shader, as specified by the caller. 6832 * 6833 * @param n_id Index of the shader. 6834 * 6835 * @return Requested string. 6836 **/ 6837 std::string FunctionalTest13::getTessellationControlShaderBody(unsigned int n_id) 6838 { 6839 std::stringstream result_sstream; 6840 6841 /* Pre-amble */ 6842 result_sstream << "#version 400\n" 6843 "\n" 6844 "#extension GL_ARB_shader_subroutine : require\n" 6845 "\n" 6846 "layout(vertices = 4) out;\n" 6847 /* Sub-routine */ 6848 "subroutine void SubroutineTCType(inout vec4 result);\n" 6849 "\n" 6850 "subroutine(SubroutineTCType) void SubroutineTC1(inout vec4 result)\n" 6851 "{\n" 6852 " result += vec4(0, " 6853 << float(n_id + 1) * 0.25f << ", 0, 0);\n" 6854 "}\n" 6855 "subroutine(SubroutineTCType) void SubroutineTC2(inout vec4 result)\n" 6856 "{\n" 6857 " result += vec4(0, " 6858 << float(n_id + 1) * 0.025f 6859 << ", 0, 0);\n" 6860 "}\n" 6861 "\n" 6862 "subroutine uniform SubroutineTCType function;\n" 6863 "\n" 6864 /* Input block */ 6865 "in VS_DATA\n" 6866 "{\n" 6867 " vec4 data;\n" 6868 "} in_vs[];\n" 6869 "\n" 6870 /* Output block */ 6871 "out TC_DATA\n" 6872 "{\n" 6873 " vec4 data;\n" 6874 "} out_tc[];\n" 6875 "\n" 6876 "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" 6877 "out gl_PerVertex { vec4 gl_Position; } gl_out[];\n" 6878 /* main() declaration */ 6879 "void main()\n" 6880 "{\n" 6881 " gl_TessLevelOuter[0] = 1.0;\n" 6882 " gl_TessLevelOuter[1] = 1.0;\n" 6883 " gl_TessLevelOuter[2] = 1.0;\n" 6884 " gl_TessLevelOuter[3] = 1.0;\n" 6885 " gl_TessLevelInner[0] = 1.0;\n" 6886 " gl_TessLevelInner[1] = 1.0;\n" 6887 " gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position;\n" 6888 " out_tc[gl_InvocationID].data = in_vs[0].data;\n" 6889 "\n" 6890 " function(out_tc[gl_InvocationID].data);\n" 6891 "}\n"; 6892 6893 return result_sstream.str(); 6894 } 6895 6896 /** Retrieves body of a tessellation evaluation shader that should be used for the test. 6897 * The subroutine implementations are slightly changed, depending on the 6898 * index of the shader, as specified by the caller. 6899 * 6900 * @param n_id Index of the shader. 6901 * 6902 * @return Requested string. 6903 **/ 6904 std::string FunctionalTest13::getTessellationEvaluationShaderBody(unsigned int n_id) 6905 { 6906 std::stringstream result_sstream; 6907 6908 /* Pre-amble */ 6909 result_sstream << "#version 400\n" 6910 "\n" 6911 "#extension GL_ARB_shader_subroutine : require\n" 6912 "\n" 6913 "layout(quads, point_mode) in;\n" 6914 /* Sub-routine */ 6915 "subroutine void SubroutineTEType(inout vec4 result);\n" 6916 "\n" 6917 "subroutine(SubroutineTEType) void SubroutineTE1(inout vec4 result)\n" 6918 "{\n" 6919 " result += vec4(0, 0, " 6920 << float(n_id + 1) * 0.325f << ", 0);\n" 6921 "}\n" 6922 "subroutine(SubroutineTEType) void SubroutineTE2(inout vec4 result)\n" 6923 "{\n" 6924 " result += vec4(0, 0, " 6925 << float(n_id + 1) * 0.0325f << ", 0);\n" 6926 "}\n" 6927 "\n" 6928 "subroutine uniform SubroutineTEType function;\n" 6929 "\n" 6930 /* Input block */ 6931 "in TC_DATA\n" 6932 "{\n" 6933 " vec4 data;\n" 6934 "} in_tc[];\n" 6935 "\n" 6936 /* Output block */ 6937 "out TE_DATA\n" 6938 "{\n" 6939 " vec4 data;\n" 6940 "} out_te;\n" 6941 "\n" 6942 "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" 6943 "out gl_PerVertex { vec4 gl_Position; };\n" 6944 /* main() declaration */ 6945 "void main()\n" 6946 "{\n" 6947 " gl_Position = gl_in[0].gl_Position;\n" 6948 " out_te.data = in_tc[0].data;\n" 6949 "\n" 6950 " function(out_te.data);\n" 6951 "}\n"; 6952 6953 return result_sstream.str(); 6954 } 6955 6956 /** Retrieves body of a vertex shader that should be used for the test. 6957 * The subroutine implementations are slightly changed, depending on the 6958 * index of the shader, as specified by the caller. 6959 * 6960 * @param n_id Index of the shader. 6961 * 6962 * @return Requested string. 6963 **/ 6964 std::string FunctionalTest13::getVertexShaderBody(unsigned int n_id) 6965 { 6966 std::stringstream result_sstream; 6967 6968 /* Pre-amble */ 6969 result_sstream << "#version 400\n" 6970 "\n" 6971 "#extension GL_ARB_shader_subroutine : require\n" 6972 "\n" 6973 /* Sub-routine */ 6974 "subroutine void SubroutineVSType(inout vec4 result);\n" 6975 "\n" 6976 "subroutine(SubroutineVSType) void SubroutineVS1(inout vec4 result)\n" 6977 "{\n" 6978 " result += vec4(" 6979 << float(n_id + 1) * 0.125f << ", 0, 0, 0);\n" 6980 "}\n" 6981 "subroutine(SubroutineVSType) void SubroutineVS2(inout vec4 result)\n" 6982 "{\n" 6983 " result += vec4(" 6984 << float(n_id + 1) * 0.0125f << ", 0, 0, 0);\n" 6985 "}\n" 6986 "\n" 6987 "subroutine uniform SubroutineVSType function;\n" 6988 "\n" 6989 /* Output block */ 6990 "out VS_DATA\n" 6991 "{\n" 6992 " vec4 data;\n" 6993 "} out_vs;\n" 6994 "\n" 6995 "out gl_PerVertex { vec4 gl_Position; };\n" 6996 /* main() declaration */ 6997 "void main()\n" 6998 "{\n" 6999 " gl_Position = vec4(0, 0, 0, 1);\n" 7000 " out_vs.data = vec4(0);\n" 7001 "\n" 7002 " function(out_vs.data);\n" 7003 "\n" 7004 "}\n"; 7005 7006 return result_sstream.str(); 7007 } 7008 7009 /** Initializes all GL objects required to run the test. Also modifies a few 7010 * GL states in order for the test to run correctly. 7011 **/ 7012 void FunctionalTest13::initTest() 7013 { 7014 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 7015 7016 /* Set up viewport */ 7017 gl.viewport(0 /* x */, 0 /* y */, m_to_width, m_to_height); 7018 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed."); 7019 7020 /* Make sure no program is used */ 7021 gl.useProgram(0); 7022 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 7023 7024 /* Generate a pipeline object */ 7025 gl.genProgramPipelines(1, &m_pipeline_id); 7026 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); 7027 7028 gl.bindProgramPipeline(m_pipeline_id); 7029 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 7030 7031 /* Initialize all shader programs */ 7032 for (unsigned int n_id = 0; n_id < 2 /* variants for each shader type */; ++n_id) 7033 { 7034 std::string fs_body = getFragmentShaderBody(n_id); 7035 const char* fs_body_raw_ptr = fs_body.c_str(); 7036 std::string gs_body = getGeometryShaderBody(n_id); 7037 const char* gs_body_raw_ptr = gs_body.c_str(); 7038 std::string tc_body = getTessellationControlShaderBody(n_id); 7039 const char* tc_body_raw_ptr = tc_body.c_str(); 7040 std::string te_body = getTessellationEvaluationShaderBody(n_id); 7041 const char* te_body_raw_ptr = te_body.c_str(); 7042 std::string vs_body = getVertexShaderBody(n_id); 7043 const char* vs_body_raw_ptr = vs_body.c_str(); 7044 7045 m_fs_po_ids[n_id] = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1 /* count */, &fs_body_raw_ptr); 7046 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 7047 7048 m_gs_po_ids[n_id] = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1 /* count */, &gs_body_raw_ptr); 7049 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 7050 7051 m_tc_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_CONTROL_SHADER, 1 /* count */, &tc_body_raw_ptr); 7052 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 7053 7054 m_te_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &te_body_raw_ptr); 7055 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 7056 7057 m_vs_po_ids[n_id] = gl.createShaderProgramv(GL_VERTEX_SHADER, 1 /* count */, &vs_body_raw_ptr); 7058 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 7059 7060 /* Verify that all shader program objects have been linked successfully */ 7061 const glw::GLuint po_ids[] = { 7062 m_fs_po_ids[n_id], m_gs_po_ids[n_id], m_tc_po_ids[n_id], m_te_po_ids[n_id], m_vs_po_ids[n_id], 7063 }; 7064 const unsigned int n_po_ids = sizeof(po_ids) / sizeof(po_ids[0]); 7065 7066 for (unsigned int n_po_id = 0; n_po_id < n_po_ids; ++n_po_id) 7067 { 7068 glw::GLint link_status = GL_FALSE; 7069 glw::GLuint po_id = po_ids[n_po_id]; 7070 7071 gl.getProgramiv(po_id, GL_LINK_STATUS, &link_status); 7072 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 7073 7074 if (link_status != GL_TRUE) 7075 { 7076 TCU_FAIL("Shader program object linking failed."); 7077 } 7078 } /* for (all shader program objects) */ 7079 } /* for (both shader program object variants) */ 7080 7081 /* Generate a texture object. We will use the base mip-map as a render-target */ 7082 gl.genTextures(1, &m_to_id); 7083 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); 7084 7085 gl.bindTexture(GL_TEXTURE_2D, m_to_id); 7086 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); 7087 7088 gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, GL_RGBA32F, m_to_width, m_to_height); 7089 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed"); 7090 7091 /* Generate and configure a FBO we will use for the draw call */ 7092 gl.genFramebuffers(1, &m_fbo_id); 7093 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed."); 7094 7095 gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); 7096 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed."); 7097 7098 gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */); 7099 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed."); 7100 7101 /* Generate & bind a VAO */ 7102 gl.genVertexArrays(1, &m_vao_id); 7103 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 7104 7105 gl.bindVertexArray(m_vao_id); 7106 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 7107 7108 /* Set up tessellation */ 7109 gl.patchParameteri(GL_PATCH_VERTICES, 1); 7110 GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed."); 7111 7112 /* Set up pixel storage alignment */ 7113 gl.pixelStorei(GL_PACK_ALIGNMENT, 1); 7114 GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed."); 7115 7116 /* Allocate enough space to hold color attachment data */ 7117 m_read_buffer = (unsigned char*)new float[m_to_width * m_to_height * 4 /* rgba */]; 7118 } 7119 7120 /** Executes test iteration. 7121 * 7122 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 7123 */ 7124 tcu::TestNode::IterateResult FunctionalTest13::iterate() 7125 { 7126 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 7127 7128 /* Do not execute the test if GL_ARB_shader_subroutine and GL_ARB_separate_shader_objects 7129 * are not supported */ 7130 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 7131 { 7132 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 7133 } 7134 7135 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects")) 7136 { 7137 throw tcu::NotSupportedError("GL_ARB_separate_shader_objects is not supported"); 7138 } 7139 7140 /* Initialize all GL objects before we continue */ 7141 initTest(); 7142 7143 /* Iterate over all possible FS/GS/TC/TE/VS permutations */ 7144 for (int n_shader_permutation = 0; n_shader_permutation < 32 /* 2^5 */; ++n_shader_permutation) 7145 { 7146 const unsigned int n_fs_idx = ((n_shader_permutation & (1 << 0)) != 0) ? 1 : 0; 7147 const unsigned int n_gs_idx = ((n_shader_permutation & (1 << 1)) != 0) ? 1 : 0; 7148 const unsigned int n_tc_idx = ((n_shader_permutation & (1 << 2)) != 0) ? 1 : 0; 7149 const unsigned int n_te_idx = ((n_shader_permutation & (1 << 3)) != 0) ? 1 : 0; 7150 const unsigned int n_vs_idx = ((n_shader_permutation & (1 << 4)) != 0) ? 1 : 0; 7151 const unsigned int fs_po_id = m_fs_po_ids[n_fs_idx]; 7152 const unsigned int gs_po_id = m_gs_po_ids[n_gs_idx]; 7153 const unsigned int tc_po_id = m_tc_po_ids[n_tc_idx]; 7154 const unsigned int te_po_id = m_te_po_ids[n_te_idx]; 7155 const unsigned int vs_po_id = m_vs_po_ids[n_vs_idx]; 7156 7157 /* Configure fragment shader stage */ 7158 gl.useProgramStages(m_pipeline_id, GL_FRAGMENT_SHADER_BIT, fs_po_id); 7159 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_FRAGMENT_SHADER_BIT bit"); 7160 7161 /* Configure geometry shader stage */ 7162 gl.useProgramStages(m_pipeline_id, GL_GEOMETRY_SHADER_BIT, gs_po_id); 7163 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_GEOMETRY_SHADER_BIT bit"); 7164 7165 /* Configure tessellation control shader stage */ 7166 gl.useProgramStages(m_pipeline_id, GL_TESS_CONTROL_SHADER_BIT, tc_po_id); 7167 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_TESS_CONTROL_SHADER_BIT bit"); 7168 7169 /* Configure tessellation evaluation shader stage */ 7170 gl.useProgramStages(m_pipeline_id, GL_TESS_EVALUATION_SHADER_BIT, te_po_id); 7171 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_TESS_EVALUATION_SHADER_BIT bit"); 7172 7173 /* Configure vertex shader stage */ 7174 gl.useProgramStages(m_pipeline_id, GL_VERTEX_SHADER_BIT, vs_po_id); 7175 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_VERTEX_SHADER_BIT bit"); 7176 7177 /* Validate the pipeline */ 7178 glw::GLint validate_status = GL_FALSE; 7179 7180 gl.validateProgramPipeline(m_pipeline_id); 7181 GLU_EXPECT_NO_ERROR(gl.getError(), "glValidateProgramPipeline() call failed."); 7182 7183 gl.getProgramPipelineiv(m_pipeline_id, GL_VALIDATE_STATUS, &validate_status); 7184 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramPipelineiv() call failed."); 7185 7186 if (validate_status != GL_TRUE) 7187 { 7188 TCU_FAIL("Program pipeline has not been validated successfully."); 7189 } 7190 7191 /* Retrieve subroutine indices */ 7192 GLuint fs_subroutine_indices[2] = { (GLuint)-1 }; 7193 GLint fs_subroutine_uniform_index = 0; 7194 GLuint gs_subroutine_indices[2] = { (GLuint)-1 }; 7195 GLint gs_subroutine_uniform_index = 0; 7196 GLuint tc_subroutine_indices[2] = { (GLuint)-1 }; 7197 GLint tc_subroutine_uniform_index = 0; 7198 GLuint te_subroutine_indices[2] = { (GLuint)-1 }; 7199 GLint te_subroutine_uniform_index = 0; 7200 GLuint vs_subroutine_indices[2] = { (GLuint)-1 }; 7201 GLint vs_subroutine_uniform_index = 0; 7202 7203 for (unsigned int n_subroutine = 0; n_subroutine < 2; ++n_subroutine) 7204 { 7205 std::stringstream fs_subroutine_name_sstream; 7206 std::stringstream gs_subroutine_name_sstream; 7207 std::stringstream tc_subroutine_name_sstream; 7208 std::stringstream te_subroutine_name_sstream; 7209 std::stringstream vs_subroutine_name_sstream; 7210 7211 fs_subroutine_name_sstream << "SubroutineFS" << (n_subroutine + 1); 7212 gs_subroutine_name_sstream << "SubroutineGS" << (n_subroutine + 1); 7213 tc_subroutine_name_sstream << "SubroutineTC" << (n_subroutine + 1); 7214 te_subroutine_name_sstream << "SubroutineTE" << (n_subroutine + 1); 7215 vs_subroutine_name_sstream << "SubroutineVS" << (n_subroutine + 1); 7216 7217 fs_subroutine_indices[n_subroutine] = 7218 gl.getSubroutineIndex(fs_po_id, GL_FRAGMENT_SHADER, fs_subroutine_name_sstream.str().c_str()); 7219 gs_subroutine_indices[n_subroutine] = 7220 gl.getSubroutineIndex(gs_po_id, GL_GEOMETRY_SHADER, gs_subroutine_name_sstream.str().c_str()); 7221 tc_subroutine_indices[n_subroutine] = 7222 gl.getSubroutineIndex(tc_po_id, GL_TESS_CONTROL_SHADER, tc_subroutine_name_sstream.str().c_str()); 7223 te_subroutine_indices[n_subroutine] = 7224 gl.getSubroutineIndex(te_po_id, GL_TESS_EVALUATION_SHADER, te_subroutine_name_sstream.str().c_str()); 7225 vs_subroutine_indices[n_subroutine] = 7226 gl.getSubroutineIndex(vs_po_id, GL_VERTEX_SHADER, vs_subroutine_name_sstream.str().c_str()); 7227 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); 7228 7229 if (fs_subroutine_indices[n_subroutine] == (GLuint)-1 || 7230 gs_subroutine_indices[n_subroutine] == (GLuint)-1 || 7231 tc_subroutine_indices[n_subroutine] == (GLuint)-1 || 7232 te_subroutine_indices[n_subroutine] == (GLuint)-1 || vs_subroutine_indices[n_subroutine] == (GLuint)-1) 7233 { 7234 m_testCtx.getLog() << tcu::TestLog::Message 7235 << "At least one subroutine was not recognized by glGetSubroutineIndex() call. " 7236 "(fs:" 7237 << fs_subroutine_indices[n_subroutine] 7238 << ", gs:" << gs_subroutine_indices[n_subroutine] 7239 << ", tc:" << tc_subroutine_indices[n_subroutine] 7240 << ", te:" << te_subroutine_indices[n_subroutine] 7241 << ", vs:" << vs_subroutine_indices[n_subroutine] << ")." 7242 << tcu::TestLog::EndMessage; 7243 7244 TCU_FAIL("At least one subroutine was not recognized"); 7245 } 7246 } /* for (both subroutines) */ 7247 7248 /* Retrieve subroutine uniform indices */ 7249 fs_subroutine_uniform_index = gl.getSubroutineUniformLocation(fs_po_id, GL_FRAGMENT_SHADER, "function"); 7250 gs_subroutine_uniform_index = gl.getSubroutineUniformLocation(gs_po_id, GL_GEOMETRY_SHADER, "function"); 7251 tc_subroutine_uniform_index = gl.getSubroutineUniformLocation(tc_po_id, GL_TESS_CONTROL_SHADER, "function"); 7252 te_subroutine_uniform_index = gl.getSubroutineUniformLocation(te_po_id, GL_TESS_EVALUATION_SHADER, "function"); 7253 vs_subroutine_uniform_index = gl.getSubroutineUniformLocation(vs_po_id, GL_VERTEX_SHADER, "function"); 7254 7255 if (fs_subroutine_uniform_index == -1 || gs_subroutine_uniform_index == -1 || 7256 tc_subroutine_uniform_index == -1 || te_subroutine_uniform_index == -1 || vs_subroutine_uniform_index == -1) 7257 { 7258 m_testCtx.getLog() << tcu::TestLog::Message << "At least one subroutine uniform is considered inactive by " 7259 "glGetSubroutineUniformLocation (" 7260 "fs:" 7261 << fs_subroutine_uniform_index << ", gs:" << gs_subroutine_uniform_index 7262 << ", tc:" << tc_subroutine_uniform_index << ", te:" << te_subroutine_uniform_index 7263 << ", vs:" << vs_subroutine_uniform_index << ")." << tcu::TestLog::EndMessage; 7264 7265 TCU_FAIL("At least one subroutine uniform is considered inactive"); 7266 } 7267 7268 /* Check if both subroutines work correctly in each stage */ 7269 for (int n_subroutine_permutation = 0; n_subroutine_permutation < 32; /* 2^5 */ 7270 ++n_subroutine_permutation) 7271 { 7272 unsigned int n_fs_subroutine = ((n_subroutine_permutation & (1 << 0)) != 0) ? 1 : 0; 7273 unsigned int n_gs_subroutine = ((n_subroutine_permutation & (1 << 1)) != 0) ? 1 : 0; 7274 unsigned int n_tc_subroutine = ((n_subroutine_permutation & (1 << 2)) != 0) ? 1 : 0; 7275 unsigned int n_te_subroutine = ((n_subroutine_permutation & (1 << 3)) != 0) ? 1 : 0; 7276 unsigned int n_vs_subroutine = ((n_subroutine_permutation & (1 << 4)) != 0) ? 1 : 0; 7277 7278 /* Configure subroutine uniforms */ 7279 struct 7280 { 7281 glw::GLenum stage; 7282 glw::GLuint po_id; 7283 glw::GLuint* indices; 7284 } configurations[] = { 7285 { GL_FRAGMENT_SHADER, fs_po_id, fs_subroutine_indices + n_fs_subroutine }, 7286 { GL_GEOMETRY_SHADER, gs_po_id, gs_subroutine_indices + n_gs_subroutine }, 7287 { GL_TESS_CONTROL_SHADER, tc_po_id, tc_subroutine_indices + n_tc_subroutine }, 7288 { GL_TESS_EVALUATION_SHADER, te_po_id, te_subroutine_indices + n_te_subroutine }, 7289 { GL_VERTEX_SHADER, vs_po_id, vs_subroutine_indices + n_vs_subroutine }, 7290 }; 7291 7292 for (int i = 0; i < 5; ++i) 7293 { 7294 gl.activeShaderProgram(m_pipeline_id, configurations[i].po_id); 7295 GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveShaderProgram() call failed."); 7296 7297 gl.uniformSubroutinesuiv(configurations[i].stage, 1 /* count */, configurations[i].indices); 7298 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed."); 7299 } 7300 7301 /* Render a full-screen quad with the pipeline */ 7302 gl.clear(GL_COLOR_BUFFER_BIT); 7303 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed."); 7304 7305 gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */); 7306 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 7307 7308 /* Read color attachment's contents */ 7309 gl.readPixels(0, /* x */ 7310 0, /* y */ 7311 m_to_width, m_to_height, GL_RGBA, GL_FLOAT, m_read_buffer); 7312 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed."); 7313 7314 /* Verify the contents */ 7315 verifyReadBuffer(n_fs_idx, n_fs_subroutine, n_gs_idx, n_gs_subroutine, n_tc_idx, n_tc_subroutine, n_te_idx, 7316 n_te_subroutine, n_vs_idx, n_vs_subroutine); 7317 } /* for (all subroutine permutations) */ 7318 } /* for (all program shader object permutations) */ 7319 7320 /** All done */ 7321 if (m_has_test_passed) 7322 { 7323 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 7324 } 7325 else 7326 { 7327 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 7328 } 7329 7330 return STOP; 7331 } 7332 7333 /** Verifies the data that have been rendered using a pipeline object. 7334 * Contents of the data depends on indices of the shaders, as well as 7335 * on the subroutines that have been activated for particular iteration. 7336 * 7337 * @param n_fs_id Index of the fragment shader used for the iteration; 7338 * @param n_fs_subroutine Index of the subroutine used in the fragment shader 7339 * for the iteration; 7340 * @param n_gs_id Index of the geometry shader used for the iteration; 7341 * @param n_gs_subroutine Index of the subroutine used in the geometry shader 7342 * for the iteration; 7343 * @param n_tc_id Index of the tessellation control shader used for the iteration; 7344 * @param n_tc_subroutine Index of the subroutine used in the tessellation control 7345 * shader for the iteration; 7346 * @param n_te_id Index of the tessellation evaluation shader used for the iteration; 7347 * @param n_te_subroutine Index of the subroutine used in the tessellation evaluation 7348 * shader for the iteration; 7349 * @param n_vs_id Index of the vertex shader used for the iteration; 7350 * @param n_vs_subroutine Index of the subroutine used in the vertex shader for 7351 * the iteration. 7352 */ 7353 void FunctionalTest13::verifyReadBuffer(unsigned int n_fs_id, unsigned int n_fs_subroutine, unsigned int n_gs_id, 7354 unsigned int n_gs_subroutine, unsigned int n_tc_id, 7355 unsigned int n_tc_subroutine, unsigned int n_te_id, 7356 unsigned int n_te_subroutine, unsigned int n_vs_id, 7357 unsigned int n_vs_subroutine) 7358 { 7359 float expected_color[4] = { 0 }; 7360 float fs_modifier[4] = { 0 }; 7361 float gs_modifier[4] = { 0 }; 7362 float tc_modifier[4] = { 0 }; 7363 float te_modifier[4] = { 0 }; 7364 float vs_modifier[4] = { 0 }; 7365 7366 if (n_fs_subroutine == 0) 7367 { 7368 for (unsigned int n_component = 0; n_component < 4; ++n_component) 7369 { 7370 fs_modifier[n_component] = float(n_fs_id + n_component + 1) / 10.0f; 7371 } 7372 } 7373 else 7374 { 7375 for (unsigned int n_component = 0; n_component < 4; ++n_component) 7376 { 7377 fs_modifier[n_component] = float(n_fs_id + n_component + 1) / 20.0f; 7378 } 7379 } 7380 7381 if (n_gs_subroutine == 0) 7382 { 7383 gs_modifier[3] = float(n_gs_id + 1) * 0.425f; 7384 } 7385 else 7386 { 7387 gs_modifier[3] = float(n_gs_id + 1) * 0.0425f; 7388 } 7389 7390 if (n_tc_subroutine == 0) 7391 { 7392 tc_modifier[1] = float(n_tc_id + 1) * 0.25f; 7393 } 7394 else 7395 { 7396 tc_modifier[1] = float(n_tc_id + 1) * 0.025f; 7397 } 7398 7399 if (n_te_subroutine == 0) 7400 { 7401 te_modifier[2] = float(n_te_id + 1) * 0.325f; 7402 } 7403 else 7404 { 7405 te_modifier[2] = float(n_te_id + 1) * 0.0325f; 7406 } 7407 7408 if (n_vs_subroutine == 0) 7409 { 7410 vs_modifier[0] = float(n_vs_id + 1) * 0.125f; 7411 } 7412 else 7413 { 7414 vs_modifier[0] = float(n_vs_id + 1) * 0.0125f; 7415 } 7416 7417 /* Determine the expected color */ 7418 for (unsigned int n_component = 0; n_component < 4 /* rgba */; ++n_component) 7419 { 7420 expected_color[n_component] = fs_modifier[n_component] + gs_modifier[n_component] + tc_modifier[n_component] + 7421 te_modifier[n_component] + vs_modifier[n_component]; 7422 } 7423 7424 /* Verify all read texels are valid */ 7425 const float epsilon = 1e-5f; 7426 bool should_continue = true; 7427 7428 for (unsigned int y = 0; y < m_to_height && should_continue; ++y) 7429 { 7430 const float* row_ptr = (const float*)m_read_buffer + y * m_to_width * 4; /* rgba */ 7431 7432 for (unsigned int x = 0; x < m_to_width && should_continue; ++x) 7433 { 7434 const float* texel_ptr = row_ptr + x * 4; /* rgba */ 7435 7436 if (de::abs(texel_ptr[0] - expected_color[0]) > epsilon || 7437 de::abs(texel_ptr[1] - expected_color[1]) > epsilon || 7438 de::abs(texel_ptr[2] - expected_color[2]) > epsilon || 7439 de::abs(texel_ptr[3] - expected_color[3]) > epsilon) 7440 { 7441 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel rendered at (" << x << ", " << y 7442 << ") for " 7443 "the following configuration: " 7444 "n_fs_id:" 7445 << n_fs_id << " n_fs_subroutine:" << n_fs_subroutine << " n_gs_id:" << n_gs_id 7446 << " n_gs_subroutine:" << n_gs_subroutine << " n_tc_id:" << n_tc_id 7447 << " n_tc_subroutine:" << n_tc_subroutine << " n_te_id:" << n_te_id 7448 << " n_te_subroutine:" << n_te_subroutine << " n_vs_id:" << n_vs_id 7449 << " n_vs_subroutine:" << n_vs_subroutine << "; expected:" 7450 "(" 7451 << expected_color[0] << ", " << expected_color[1] << ", " << expected_color[2] 7452 << ", " << expected_color[3] << "), found:" 7453 "(" 7454 << texel_ptr[0] << ", " << texel_ptr[1] << ", " << texel_ptr[2] << ", " 7455 << texel_ptr[3] << ")." << tcu::TestLog::EndMessage; 7456 7457 m_has_test_passed = false; 7458 should_continue = false; 7459 } 7460 } /* for (all columns) */ 7461 } /* for (all rows) */ 7462 } 7463 7464 /** Constructor 7465 * 7466 * @param context CTS context 7467 **/ 7468 FunctionalTest14_15::FunctionalTest14_15(deqp::Context& context) 7469 : TestCase(context, "structure_parameters_program_binary", "Verify structures can be used as parameters") 7470 , m_uniform_location(0) 7471 { 7472 } 7473 7474 /** Execute test 7475 * 7476 * @return tcu::TestNode::STOP 7477 **/ 7478 tcu::TestNode::IterateResult FunctionalTest14_15::iterate() 7479 { 7480 static const GLchar* vertex_shader_code = 7481 "#version 400 core\n" 7482 "#extension GL_ARB_shader_subroutine : require\n" 7483 "\n" 7484 "precision highp float;\n" 7485 "\n" 7486 "struct data\n" 7487 "{\n" 7488 " uint r;\n" 7489 " uint g;\n" 7490 " uint b;\n" 7491 " uint a;\n" 7492 "};\n" 7493 "\n" 7494 "subroutine void routine_type_1(in data iparam, out data oparam);\n" 7495 "subroutine void routine_type_2(inout data arg);\n" 7496 "\n" 7497 "subroutine (routine_type_1) void invert(in data iparam, out data oparam)\n" 7498 "{\n" 7499 " oparam.r = iparam.a;\n" 7500 " oparam.g = iparam.b;\n" 7501 " oparam.b = iparam.g;\n" 7502 " oparam.a = iparam.r;\n" 7503 "}\n" 7504 "\n" 7505 "subroutine (routine_type_1) void increment(in data iparam, out data oparam)\n" 7506 "{\n" 7507 " oparam.r = 1 + iparam.r;\n" 7508 " oparam.g = 1 + iparam.g;\n" 7509 " oparam.b = 1 + iparam.b;\n" 7510 " oparam.a = 1 + iparam.a;\n" 7511 "}\n" 7512 "\n" 7513 "subroutine (routine_type_2) void div_by_2(inout data arg)\n" 7514 "{\n" 7515 " arg.r = arg.r / 2;\n" 7516 " arg.g = arg.g / 2;\n" 7517 " arg.b = arg.b / 2;\n" 7518 " arg.a = arg.a / 2;\n" 7519 "}\n" 7520 "\n" 7521 "subroutine (routine_type_2) void decrement(inout data arg)\n" 7522 "{\n" 7523 " arg.r = arg.r - 1;\n" 7524 " arg.g = arg.g - 1;\n" 7525 " arg.b = arg.b - 1;\n" 7526 " arg.a = arg.a - 1;\n" 7527 "}\n" 7528 "\n" 7529 "subroutine uniform routine_type_1 routine_1;\n" 7530 "subroutine uniform routine_type_2 routine_2;\n" 7531 "\n" 7532 "uniform uvec4 uni_input;\n" 7533 "\n" 7534 "out uvec4 out_routine_1;\n" 7535 "out uvec4 out_routine_2;\n" 7536 "\n" 7537 "\n" 7538 "void main()\n" 7539 "{\n" 7540 " data routine_1_input;\n" 7541 " data routine_1_output;\n" 7542 " data routine_2_arg;\n" 7543 "\n" 7544 " routine_1_input.r = uni_input.r;\n" 7545 " routine_1_input.g = uni_input.g;\n" 7546 " routine_1_input.b = uni_input.b;\n" 7547 " routine_1_input.a = uni_input.a;\n" 7548 "\n" 7549 " routine_2_arg.r = uni_input.r;\n" 7550 " routine_2_arg.g = uni_input.g;\n" 7551 " routine_2_arg.b = uni_input.b;\n" 7552 " routine_2_arg.a = uni_input.a;\n" 7553 "\n" 7554 " routine_1(routine_1_input, routine_1_output);\n" 7555 " routine_2(routine_2_arg);\n" 7556 "\n" 7557 " out_routine_1.r = routine_1_output.r;\n" 7558 " out_routine_1.g = routine_1_output.g;\n" 7559 " out_routine_1.b = routine_1_output.b;\n" 7560 " out_routine_1.a = routine_1_output.a;\n" 7561 "\n" 7562 " out_routine_2.r = routine_2_arg.r;\n" 7563 " out_routine_2.g = routine_2_arg.g;\n" 7564 " out_routine_2.b = routine_2_arg.b;\n" 7565 " out_routine_2.a = routine_2_arg.a;\n" 7566 "}\n" 7567 "\n"; 7568 7569 static const GLchar* subroutine_names[][2] = { { "invert", "increment" }, { "div_by_2", "decrement" } }; 7570 static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]); 7571 7572 static const GLchar* subroutine_uniform_names[] = { "routine_1", "routine_2" }; 7573 static const GLuint n_subroutine_uniform_names = 7574 sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); 7575 7576 static const GLchar* uniform_name = "uni_input"; 7577 static const GLchar* varying_names[] = { "out_routine_1", "out_routine_2" }; 7578 7579 static const GLuint n_varying_names = sizeof(varying_names) / sizeof(varying_names[0]); 7580 static const GLuint transform_feedback_buffer_size = n_varying_names * 4 * sizeof(GLuint); 7581 7582 /* Test data */ 7583 static const Utils::vec4<GLuint> uni_input[] = { Utils::vec4<GLuint>(8, 64, 4096, 16777216), 7584 Utils::vec4<GLuint>(8, 64, 4096, 16777216) }; 7585 7586 static const Utils::vec4<GLuint> out_routine_1[] = { Utils::vec4<GLuint>(16777216, 4096, 64, 8), 7587 Utils::vec4<GLuint>(9, 65, 4097, 16777217) }; 7588 7589 static const Utils::vec4<GLuint> out_routine_2[] = { Utils::vec4<GLuint>(4, 32, 2048, 8388608), 7590 Utils::vec4<GLuint>(7, 63, 4095, 16777215) }; 7591 7592 static const GLuint n_test_cases = 2; 7593 7594 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 7595 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 7596 { 7597 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 7598 } 7599 7600 /* GL objects */ 7601 Utils::program program(m_context); 7602 Utils::buffer transform_feedback_buffer(m_context); 7603 Utils::vertexArray vao(m_context); 7604 7605 bool is_program_binary_supported = program.isProgramBinarySupported(); 7606 7607 /* Init GL objects */ 7608 program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, 7609 varying_names /* varying_names */, n_varying_names /* n_varyings */); 7610 7611 /* Do not execute the test if GL_ARB_get_program_binary is not supported */ 7612 if (true == is_program_binary_supported) 7613 { 7614 /* Get subroutine indices */ 7615 for (GLuint type = 0; type < n_subroutine_types; ++type) 7616 { 7617 m_initial_subroutine_indices[type][0] = 7618 program.getSubroutineIndex(subroutine_names[type][0], GL_VERTEX_SHADER); 7619 7620 m_initial_subroutine_indices[type][1] = 7621 program.getSubroutineIndex(subroutine_names[type][1], GL_VERTEX_SHADER); 7622 } 7623 7624 /* Get subroutine uniform locations */ 7625 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) 7626 { 7627 m_initial_subroutine_uniform_locations[uniform] = 7628 program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); 7629 } 7630 7631 /* Delete program and recreate it from binary */ 7632 std::vector<GLubyte> program_binary; 7633 GLenum binary_format; 7634 7635 program.getBinary(program_binary, binary_format); 7636 program.remove(); 7637 program.createFromBinary(program_binary, binary_format); 7638 } 7639 7640 program.use(); 7641 7642 vao.generate(); 7643 vao.bind(); 7644 7645 transform_feedback_buffer.generate(); 7646 transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, 7647 GL_DYNAMIC_COPY); 7648 transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); 7649 7650 /* Get subroutine indices */ 7651 for (GLuint type = 0; type < n_subroutine_types; ++type) 7652 { 7653 m_subroutine_indices[type][0] = program.getSubroutineIndex(subroutine_names[type][0], GL_VERTEX_SHADER); 7654 m_subroutine_indices[type][1] = program.getSubroutineIndex(subroutine_names[type][1], GL_VERTEX_SHADER); 7655 } 7656 7657 /* Get subroutine uniform locations */ 7658 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) 7659 { 7660 m_subroutine_uniform_locations[uniform] = 7661 program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); 7662 } 7663 7664 /* Get uniform locations */ 7665 m_uniform_location = program.getUniformLocation(uniform_name); 7666 7667 /* Test */ 7668 bool result = true; 7669 7670 /* Test program binary */ 7671 if (true == is_program_binary_supported) 7672 { 7673 /* Test indices and locations */ 7674 if (false == testIndicesAndLocations()) 7675 { 7676 static const GLuint n_subroutines_per_type = 2; 7677 7678 m_context.getTestContext().getLog() << tcu::TestLog::Message 7679 << "Error. Subroutine indices or subroutine uniform location changed." 7680 << tcu::TestLog::EndMessage; 7681 7682 for (GLuint type = 0; type < n_subroutine_types; ++type) 7683 { 7684 for (GLuint i = 0; i < n_subroutines_per_type; ++i) 7685 { 7686 m_context.getTestContext().getLog() 7687 << tcu::TestLog::Message << "Subroutine: " << subroutine_names[type][i] 7688 << " index: " << m_subroutine_indices[type][i] 7689 << " initial index: " << m_initial_subroutine_indices[type][i] << tcu::TestLog::EndMessage; 7690 } 7691 } 7692 7693 for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) 7694 { 7695 m_context.getTestContext().getLog() 7696 << tcu::TestLog::Message << "Subroutine uniform: " << subroutine_uniform_names[uniform] 7697 << " location: " << m_subroutine_uniform_locations[uniform] 7698 << " initial location: " << m_initial_subroutine_uniform_locations[uniform] 7699 << tcu::TestLog::EndMessage; 7700 } 7701 7702 result = false; 7703 } 7704 7705 /* Test draw with deafult set of subroutines */ 7706 if (false == testDefaultSubroutineSet(uni_input[0], out_routine_1, out_routine_2)) 7707 { 7708 result = false; 7709 } 7710 } 7711 7712 for (GLuint i = 0; i < n_test_cases; ++i) 7713 { 7714 if (false == testDraw(i, uni_input[i], out_routine_1[i], out_routine_2[i])) 7715 { 7716 result = false; 7717 } 7718 } 7719 7720 /* Set result */ 7721 if (true == result) 7722 { 7723 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 7724 } 7725 else 7726 { 7727 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 7728 } 7729 7730 /* Done */ 7731 return tcu::TestNode::STOP; 7732 } 7733 7734 /** Execute draw call and verify results 7735 * 7736 * @param uni_input Input data 7737 * @param expected_routine_1_result Set of expected results of "routine_1" 7738 * @param expected_routine_2_result Set of expected results of "routine_2" 7739 * 7740 * @return true if test pass, false otherwise 7741 **/ 7742 bool FunctionalTest14_15::testDefaultSubroutineSet(const Utils::vec4<glw::GLuint>& uni_input, 7743 const Utils::vec4<glw::GLuint> expected_routine_1_result[2], 7744 const Utils::vec4<glw::GLuint> expected_routine_2_result[2]) const 7745 { 7746 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 7747 bool result = true; 7748 7749 /* Set up input data uniforms */ 7750 gl.uniform4ui(m_uniform_location, uni_input.m_x, uni_input.m_y, uni_input.m_z, uni_input.m_w); 7751 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 7752 7753 /* Execute draw call with transform feedback */ 7754 gl.beginTransformFeedback(GL_POINTS); 7755 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 7756 7757 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 7758 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 7759 7760 gl.endTransformFeedback(); 7761 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 7762 7763 /* Capture results */ 7764 GLuint* feedback_data = (GLuint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 7765 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 7766 7767 Utils::vec4<GLuint> routine_1_result; 7768 Utils::vec4<GLuint> routine_2_result; 7769 7770 routine_1_result.m_x = feedback_data[0 + 0]; 7771 routine_1_result.m_y = feedback_data[0 + 1]; 7772 routine_1_result.m_z = feedback_data[0 + 2]; 7773 routine_1_result.m_w = feedback_data[0 + 3]; 7774 7775 routine_2_result.m_x = feedback_data[4 + 0]; 7776 routine_2_result.m_y = feedback_data[4 + 1]; 7777 routine_2_result.m_z = feedback_data[4 + 2]; 7778 routine_2_result.m_w = feedback_data[4 + 3]; 7779 7780 /* Unmap buffer */ 7781 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 7782 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 7783 7784 /* Verifiy */ 7785 result = result && 7786 ((routine_1_result == expected_routine_1_result[0]) || (routine_1_result == expected_routine_1_result[1])); 7787 7788 result = result && 7789 ((routine_2_result == expected_routine_2_result[0]) || (routine_2_result == expected_routine_2_result[1])); 7790 7791 /* Log error if any */ 7792 if (false == result) 7793 { 7794 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." 7795 << tcu::TestLog::EndMessage; 7796 7797 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 7798 7799 message << "Routine_1, result: "; 7800 7801 routine_1_result.log(message); 7802 7803 message << "Routine_2, result: "; 7804 7805 routine_2_result.log(message); 7806 7807 message << tcu::TestLog::EndMessage; 7808 } 7809 7810 /* Done */ 7811 return result; 7812 } 7813 7814 /** Execute draw call and verify results 7815 * 7816 * @param routine_configuration Subroutine "type" ordinal 7817 * @param uni_input Input data 7818 * @param expected_routine_1_result Expected results of "routine_1" 7819 * @param expected_routine_2_result Expected results of "routine_2" 7820 * 7821 * @return true if test pass, false otherwise 7822 **/ 7823 bool FunctionalTest14_15::testDraw(glw::GLuint routine_configuration, const Utils::vec4<glw::GLuint>& uni_input, 7824 const Utils::vec4<glw::GLuint>& expected_routine_1_result, 7825 const Utils::vec4<glw::GLuint>& expected_routine_2_result) const 7826 { 7827 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 7828 bool result = true; 7829 GLuint subroutine_indices[2]; 7830 static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); 7831 7832 /* Set up input data uniforms */ 7833 gl.uniform4ui(m_uniform_location, uni_input.m_x, uni_input.m_y, uni_input.m_z, uni_input.m_w); 7834 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); 7835 7836 /* Prepare subroutine uniform data */ 7837 for (GLuint i = 0; i < n_subroutine_uniforms; ++i) 7838 { 7839 const GLuint location = m_subroutine_uniform_locations[i]; 7840 7841 subroutine_indices[location] = m_subroutine_indices[i][routine_configuration]; 7842 } 7843 7844 /* Set up subroutine uniforms */ 7845 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); 7846 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); 7847 7848 /* Execute draw call with transform feedback */ 7849 gl.beginTransformFeedback(GL_POINTS); 7850 GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); 7851 7852 gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); 7853 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 7854 7855 gl.endTransformFeedback(); 7856 GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); 7857 7858 /* Capture results */ 7859 GLuint* feedback_data = (GLuint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 7860 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 7861 7862 Utils::vec4<GLuint> routine_1_result; 7863 Utils::vec4<GLuint> routine_2_result; 7864 7865 routine_1_result.m_x = feedback_data[0 + 0]; 7866 routine_1_result.m_y = feedback_data[0 + 1]; 7867 routine_1_result.m_z = feedback_data[0 + 2]; 7868 routine_1_result.m_w = feedback_data[0 + 3]; 7869 7870 routine_2_result.m_x = feedback_data[4 + 0]; 7871 routine_2_result.m_y = feedback_data[4 + 1]; 7872 routine_2_result.m_z = feedback_data[4 + 2]; 7873 routine_2_result.m_w = feedback_data[4 + 3]; 7874 7875 /* Unmap buffer */ 7876 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 7877 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 7878 7879 /* Verifiy */ 7880 result = result && (routine_1_result == expected_routine_1_result); 7881 result = result && (routine_2_result == expected_routine_2_result); 7882 7883 /* Log error if any */ 7884 if (false == result) 7885 { 7886 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." 7887 << tcu::TestLog::EndMessage; 7888 7889 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 7890 7891 message << "Routine_1, result: "; 7892 7893 routine_1_result.log(message); 7894 7895 message << ", expected: "; 7896 7897 expected_routine_1_result.log(message); 7898 7899 message << "Routine_2, result: "; 7900 7901 routine_2_result.log(message); 7902 7903 message << ", expected: "; 7904 7905 expected_routine_2_result.log(message); 7906 7907 message << tcu::TestLog::EndMessage; 7908 } 7909 7910 /* Done */ 7911 return result; 7912 } 7913 7914 /** Verify initial and current values of subroutine indices and subroutines uniform locations 7915 * 7916 * @return true if test pass, false otherwise 7917 **/ 7918 bool FunctionalTest14_15::testIndicesAndLocations() const 7919 { 7920 static const GLuint n_subroutine_types = 2; 7921 bool result = true; 7922 7923 /* Verify subroutine indices */ 7924 for (GLuint type = 0; type < n_subroutine_types; ++type) 7925 { 7926 result = result && (m_subroutine_indices[type][0] == m_initial_subroutine_indices[type][0]); 7927 result = result && (m_subroutine_indices[type][1] == m_initial_subroutine_indices[type][1]); 7928 } 7929 7930 /* Verify subroutine uniform locations */ 7931 for (GLuint uniform = 0; uniform < n_subroutine_types; ++uniform) 7932 { 7933 result = result && (m_subroutine_uniform_locations[uniform] == m_initial_subroutine_uniform_locations[uniform]); 7934 } 7935 7936 return result; 7937 } 7938 7939 /** Constructor. 7940 * 7941 * @param context Rendering context. 7942 * 7943 **/ 7944 FunctionalTest16::FunctionalTest16(deqp::Context& context) 7945 : TestCase(context, "subroutine_uniform_reset", 7946 "Checks that when the active program for a shader stage is re-linke or " 7947 "changed by a call to UseProgram, BindProgramPipeline, or UseProgramStages," 7948 " subroutine uniforms for that stage are reset to arbitrarily chosen default " 7949 "functions with compatible subroutine types.") 7950 , m_are_pipeline_objects_supported(false) 7951 , m_has_test_passed(true) 7952 { 7953 memset(m_fs_ids, 0, sizeof(m_fs_ids)); 7954 memset(m_gs_ids, 0, sizeof(m_gs_ids)); 7955 memset(m_po_ids, 0, sizeof(m_po_ids)); 7956 memset(m_tc_ids, 0, sizeof(m_tc_ids)); 7957 memset(m_te_ids, 0, sizeof(m_te_ids)); 7958 memset(m_vs_ids, 0, sizeof(m_vs_ids)); 7959 7960 memset(m_fs_po_ids, 0, sizeof(m_fs_po_ids)); 7961 memset(m_gs_po_ids, 0, sizeof(m_gs_po_ids)); 7962 memset(m_pipeline_object_ids, 0, sizeof(m_pipeline_object_ids)); 7963 memset(m_tc_po_ids, 0, sizeof(m_tc_po_ids)); 7964 memset(m_te_po_ids, 0, sizeof(m_te_po_ids)); 7965 memset(m_vs_po_ids, 0, sizeof(m_vs_po_ids)); 7966 } 7967 7968 /** Deinitializes all GL objects that may have been created during test execution. */ 7969 void FunctionalTest16::deinit() 7970 { 7971 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 7972 7973 for (unsigned int n_id = 0; n_id < 2; ++n_id) 7974 { 7975 if (m_fs_ids[n_id] != 0) 7976 { 7977 gl.deleteShader(m_fs_ids[n_id]); 7978 7979 m_fs_ids[n_id] = 0; 7980 } 7981 7982 if (m_fs_po_ids[n_id] != 0) 7983 { 7984 gl.deleteProgram(m_fs_po_ids[n_id]); 7985 7986 m_fs_po_ids[n_id] = 0; 7987 } 7988 7989 if (m_gs_ids[n_id] != 0) 7990 { 7991 gl.deleteShader(m_gs_ids[n_id]); 7992 7993 m_gs_ids[n_id] = 0; 7994 } 7995 7996 if (m_gs_po_ids[n_id] != 0) 7997 { 7998 gl.deleteProgram(m_gs_po_ids[n_id]); 7999 8000 m_gs_po_ids[n_id] = 0; 8001 } 8002 8003 if (m_pipeline_object_ids[n_id] != 0) 8004 { 8005 gl.deleteProgramPipelines(1 /* n */, m_pipeline_object_ids + n_id); 8006 } 8007 8008 if (m_po_ids[n_id] != 0) 8009 { 8010 gl.deleteProgram(m_po_ids[n_id]); 8011 8012 m_po_ids[n_id] = 0; 8013 } 8014 8015 if (m_tc_ids[n_id] != 0) 8016 { 8017 gl.deleteShader(m_tc_ids[n_id]); 8018 8019 m_tc_ids[n_id] = 0; 8020 } 8021 8022 if (m_tc_po_ids[n_id] != 0) 8023 { 8024 gl.deleteProgram(m_tc_po_ids[n_id]); 8025 8026 m_tc_po_ids[n_id] = 0; 8027 } 8028 8029 if (m_te_ids[n_id] != 0) 8030 { 8031 gl.deleteShader(m_te_ids[n_id]); 8032 8033 m_te_ids[n_id] = 0; 8034 } 8035 8036 if (m_te_po_ids[n_id] != 0) 8037 { 8038 gl.deleteProgram(m_te_po_ids[n_id]); 8039 8040 m_te_po_ids[n_id] = 0; 8041 } 8042 8043 if (m_vs_ids[n_id] != 0) 8044 { 8045 gl.deleteShader(m_vs_ids[n_id]); 8046 8047 m_vs_ids[n_id] = 0; 8048 } 8049 8050 if (m_vs_po_ids[n_id] != 0) 8051 { 8052 gl.deleteProgram(m_vs_po_ids[n_id]); 8053 8054 m_vs_po_ids[n_id] = 0; 8055 } 8056 } /* for (both IDs) */ 8057 } 8058 8059 /** Retrieves body of a shader that should be used for user-specified shader stage. 8060 * This function returns slightly different implementations, depending on index of 8061 * the program/pipeline object the shader will be used for. 8062 * 8063 * @param shader_stage Stage the shader body is to be returned for. 8064 * @param n_id Index of the shader (as per description). 8065 * 8066 * @return Requested string. 8067 **/ 8068 std::string FunctionalTest16::getShaderBody(const Utils::_shader_stage& shader_stage, const unsigned int& n_id) const 8069 { 8070 std::stringstream result_sstream; 8071 8072 result_sstream << "#version 400\n" 8073 "\n" 8074 "#extension GL_ARB_shader_subroutine : require\n" 8075 "\n"; 8076 8077 switch (shader_stage) 8078 { 8079 case Utils::SHADER_STAGE_VERTEX: 8080 { 8081 result_sstream << "out gl_PerVertex { vec4 gl_Position; } ;\n"; 8082 break; 8083 } 8084 case Utils::SHADER_STAGE_GEOMETRY: 8085 { 8086 result_sstream << "layout(points) in;\n" 8087 "layout(points, max_vertices = 1) out;\n"; 8088 result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"; 8089 result_sstream << "out gl_PerVertex { vec4 gl_Position; } ;\n"; 8090 break; 8091 } 8092 8093 case Utils::SHADER_STAGE_TESSELLATION_CONTROL: 8094 { 8095 result_sstream << "layout(vertices = 4) out;\n"; 8096 result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"; 8097 result_sstream << "out gl_PerVertex { vec4 gl_Position; } gl_out[];\n"; 8098 break; 8099 } 8100 8101 case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: 8102 { 8103 result_sstream << "layout(quads) in;\n"; 8104 result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"; 8105 result_sstream << "out gl_PerVertex { vec4 gl_Position; };\n"; 8106 break; 8107 } 8108 8109 default: 8110 break; 8111 } /* switch (shader_stage) */ 8112 8113 result_sstream << "\n" 8114 "subroutine void subroutineType (inout vec4 result);\n" 8115 "subroutine vec4 subroutineType2(in vec4 data);\n" 8116 "\n" 8117 "subroutine(subroutineType) void function1(inout vec4 result)\n" 8118 "{\n" 8119 " result += vec4(" 8120 << (n_id + 1) << ", " << (n_id + 2) << ", " << (n_id + 3) << ", " << (n_id + 4) 8121 << ");\n" 8122 "}\n" 8123 "subroutine(subroutineType) void function2(inout vec4 result)\n" 8124 "{\n" 8125 " result += vec4(" 8126 << (n_id + 2) << ", " << (n_id + 3) << ", " << (n_id + 4) << ", " << (n_id + 5) 8127 << ");\n" 8128 "}\n" 8129 "\n" 8130 "subroutine(subroutineType2) vec4 function3(in vec4 data)\n" 8131 "{\n" 8132 " return data * data;\n" 8133 "}\n" 8134 "subroutine(subroutineType2) vec4 function4(in vec4 data)\n" 8135 "{\n" 8136 " return data + data;\n" 8137 "}\n" 8138 "\n" 8139 "subroutine uniform subroutineType subroutine1;\n" 8140 "subroutine uniform subroutineType subroutine2;\n" 8141 "subroutine uniform subroutineType2 subroutine3;\n" 8142 "subroutine uniform subroutineType2 subroutine4;\n" 8143 "\n"; 8144 8145 if (shader_stage == Utils::SHADER_STAGE_FRAGMENT) 8146 { 8147 result_sstream << "out vec4 result;\n"; 8148 } 8149 8150 result_sstream << "void main()\n" 8151 "{\n"; 8152 8153 switch (shader_stage) 8154 { 8155 case Utils::SHADER_STAGE_FRAGMENT: 8156 { 8157 result_sstream << " result = vec4(0);\n" 8158 << " subroutine1(result);\n" 8159 " subroutine2(result);\n" 8160 " result = subroutine3(result) + subroutine4(result);\n"; 8161 8162 break; 8163 } 8164 8165 case Utils::SHADER_STAGE_GEOMETRY: 8166 { 8167 result_sstream << " gl_Position = vec4(0);\n" 8168 " subroutine1(gl_Position);\n" 8169 " subroutine2(gl_Position);\n" 8170 " gl_Position = subroutine3(gl_Position) + subroutine4(gl_Position);\n" 8171 " EmitVertex();\n"; 8172 8173 break; 8174 } 8175 8176 case Utils::SHADER_STAGE_TESSELLATION_CONTROL: 8177 { 8178 result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0);\n" 8179 " subroutine1(gl_out[gl_InvocationID].gl_Position);\n" 8180 " subroutine2(gl_out[gl_InvocationID].gl_Position);\n" 8181 " gl_out[gl_InvocationID].gl_Position = subroutine3(gl_in[0].gl_Position) + " 8182 "subroutine4(gl_in[0].gl_Position);\n"; 8183 8184 break; 8185 } 8186 8187 case Utils::SHADER_STAGE_VERTEX: 8188 case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: 8189 { 8190 result_sstream << " gl_Position = vec4(0);\n" 8191 " subroutine1(gl_Position);\n" 8192 " subroutine2(gl_Position);\n" 8193 " gl_Position = subroutine3(gl_Position) + subroutine4(gl_Position);\n"; 8194 8195 break; 8196 } 8197 8198 default: 8199 break; 8200 } /* switch (shader_stage) */ 8201 8202 result_sstream << "}\n"; 8203 8204 return result_sstream.str(); 8205 } 8206 8207 /** Initializes all objects required to run the test. */ 8208 void FunctionalTest16::initTest() 8209 { 8210 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 8211 8212 for (unsigned int n_id = 0; n_id < 2 /* test program/shader objects */; ++n_id) 8213 { 8214 const std::string fs_body = getShaderBody(Utils::SHADER_STAGE_FRAGMENT, n_id); 8215 const std::string gs_body = getShaderBody(Utils::SHADER_STAGE_GEOMETRY, n_id); 8216 const std::string tc_body = getShaderBody(Utils::SHADER_STAGE_TESSELLATION_CONTROL, n_id); 8217 const std::string te_body = getShaderBody(Utils::SHADER_STAGE_TESSELLATION_EVALUATION, n_id); 8218 const std::string vs_body = getShaderBody(Utils::SHADER_STAGE_VERTEX, n_id); 8219 8220 if (!Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, DE_NULL, /* xfb_varyings */ 8221 DE_NULL, /* n_xfb_varyings */ 8222 m_vs_ids + n_id, m_tc_ids + n_id, m_te_ids + n_id, m_gs_ids + n_id, m_fs_ids + n_id, 8223 m_po_ids + n_id)) 8224 { 8225 m_testCtx.getLog() << tcu::TestLog::Message << "Failed to build test program object, index:" 8226 "[" 8227 << n_id << "]" << tcu::TestLog::EndMessage; 8228 8229 TCU_FAIL("Failed to build a test program"); 8230 } 8231 8232 if (m_are_pipeline_objects_supported) 8233 { 8234 /* Initialize shader program objects */ 8235 const char* fs_body_raw_ptr = fs_body.c_str(); 8236 const char* gs_body_raw_ptr = gs_body.c_str(); 8237 glw::GLint link_status[5] = { GL_FALSE }; 8238 const char* tc_body_raw_ptr = tc_body.c_str(); 8239 const char* te_body_raw_ptr = te_body.c_str(); 8240 const char* vs_body_raw_ptr = vs_body.c_str(); 8241 8242 m_fs_po_ids[n_id] = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1 /* count */, &fs_body_raw_ptr); 8243 m_gs_po_ids[n_id] = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1 /* count */, &gs_body_raw_ptr); 8244 m_tc_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_CONTROL_SHADER, 1 /* count */, &tc_body_raw_ptr); 8245 m_te_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &te_body_raw_ptr); 8246 m_vs_po_ids[n_id] = gl.createShaderProgramv(GL_VERTEX_SHADER, 1 /* count */, &vs_body_raw_ptr); 8247 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); 8248 8249 gl.getProgramiv(m_fs_po_ids[n_id], GL_LINK_STATUS, link_status + 0); 8250 gl.getProgramiv(m_gs_po_ids[n_id], GL_LINK_STATUS, link_status + 1); 8251 gl.getProgramiv(m_tc_po_ids[n_id], GL_LINK_STATUS, link_status + 2); 8252 gl.getProgramiv(m_te_po_ids[n_id], GL_LINK_STATUS, link_status + 3); 8253 gl.getProgramiv(m_vs_po_ids[n_id], GL_LINK_STATUS, link_status + 4); 8254 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 8255 8256 if (link_status[0] == GL_FALSE) 8257 TCU_FAIL("Fragment shader program failed to link"); 8258 if (link_status[1] == GL_FALSE) 8259 TCU_FAIL("Geometry shader program failed to link"); 8260 if (link_status[2] == GL_FALSE) 8261 TCU_FAIL("Tessellation control shader program failed to link"); 8262 if (link_status[3] == GL_FALSE) 8263 TCU_FAIL("Tessellation evaluation shader program failed to link"); 8264 if (link_status[4] == GL_FALSE) 8265 TCU_FAIL("Vertex shader program failed to link"); 8266 8267 /* Initialize pipeline program object */ 8268 gl.genProgramPipelines(1 /* n */, m_pipeline_object_ids + n_id); 8269 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); 8270 8271 gl.useProgramStages(m_pipeline_object_ids[n_id], GL_FRAGMENT_SHADER_BIT, m_fs_po_ids[n_id]); 8272 gl.useProgramStages(m_pipeline_object_ids[n_id], GL_GEOMETRY_SHADER_BIT, m_gs_po_ids[n_id]); 8273 gl.useProgramStages(m_pipeline_object_ids[n_id], GL_TESS_CONTROL_SHADER_BIT, m_tc_po_ids[n_id]); 8274 gl.useProgramStages(m_pipeline_object_ids[n_id], GL_TESS_EVALUATION_SHADER_BIT, m_te_po_ids[n_id]); 8275 gl.useProgramStages(m_pipeline_object_ids[n_id], GL_VERTEX_SHADER_BIT, m_vs_po_ids[n_id]); 8276 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8277 } 8278 8279 /* Retrieve subroutine locations */ 8280 struct _item 8281 { 8282 glw::GLuint po_id; 8283 _shader_stage& stage; 8284 glw::GLuint so_id; 8285 glw::GLenum so_type; 8286 } items[] = { 8287 { m_po_ids[n_id], m_po_descriptors[n_id].fragment, m_fs_ids[n_id], GL_FRAGMENT_SHADER }, 8288 { m_po_ids[n_id], m_po_descriptors[n_id].geometry, m_gs_ids[n_id], GL_GEOMETRY_SHADER }, 8289 { m_po_ids[n_id], m_po_descriptors[n_id].tess_control, m_tc_ids[n_id], GL_TESS_CONTROL_SHADER }, 8290 { m_po_ids[n_id], m_po_descriptors[n_id].tess_evaluation, m_te_ids[n_id], GL_TESS_EVALUATION_SHADER }, 8291 { m_po_ids[n_id], m_po_descriptors[n_id].vertex, m_vs_ids[n_id], GL_VERTEX_SHADER }, 8292 8293 { m_fs_po_ids[n_id], m_fs_po_descriptors[n_id], m_fs_po_ids[n_id], GL_FRAGMENT_SHADER }, 8294 { m_gs_po_ids[n_id], m_gs_po_descriptors[n_id], m_gs_po_ids[n_id], GL_GEOMETRY_SHADER }, 8295 { m_tc_po_ids[n_id], m_tc_po_descriptors[n_id], m_tc_po_ids[n_id], GL_TESS_CONTROL_SHADER }, 8296 { m_te_po_ids[n_id], m_te_po_descriptors[n_id], m_te_po_ids[n_id], GL_TESS_EVALUATION_SHADER }, 8297 { m_vs_po_ids[n_id], m_vs_po_descriptors[n_id], m_vs_po_ids[n_id], GL_VERTEX_SHADER }, 8298 }; 8299 const unsigned int n_items = sizeof(items) / sizeof(items[0]); 8300 8301 for (unsigned int n_item = 0; n_item < n_items; ++n_item) 8302 { 8303 _item& current_item = items[n_item]; 8304 8305 current_item.stage.function1_index = 8306 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function1"); 8307 current_item.stage.function2_index = 8308 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function2"); 8309 current_item.stage.function3_index = 8310 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function3"); 8311 current_item.stage.function4_index = 8312 gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function4"); 8313 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); 8314 8315 if (current_item.stage.function1_index == GL_INVALID_INDEX || 8316 current_item.stage.function2_index == GL_INVALID_INDEX || 8317 current_item.stage.function3_index == GL_INVALID_INDEX || 8318 current_item.stage.function4_index == GL_INVALID_INDEX) 8319 { 8320 TCU_FAIL("Subroutine name was not recognized."); 8321 } 8322 8323 current_item.stage.subroutine1_uniform_location = 8324 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine1"); 8325 current_item.stage.subroutine2_uniform_location = 8326 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine2"); 8327 current_item.stage.subroutine3_uniform_location = 8328 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine3"); 8329 current_item.stage.subroutine4_uniform_location = 8330 gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine4"); 8331 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed."); 8332 8333 if (current_item.stage.subroutine1_uniform_location == -1 || 8334 current_item.stage.subroutine2_uniform_location == -1 || 8335 current_item.stage.subroutine3_uniform_location == -1 || 8336 current_item.stage.subroutine4_uniform_location == -1) 8337 { 8338 TCU_FAIL("Subroutine uniform name was not recognized."); 8339 } 8340 8341 if (m_po_ids[n_id] == current_item.po_id) 8342 { 8343 gl.useProgram(current_item.po_id); 8344 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 8345 } 8346 else 8347 { 8348 /* Temporarily bind the program pipeline. */ 8349 gl.bindProgramPipeline(m_pipeline_object_ids[n_id]); 8350 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 8351 } 8352 8353 gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine1_uniform_location, 8354 ¤t_item.stage.default_subroutine1_value); 8355 gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine2_uniform_location, 8356 ¤t_item.stage.default_subroutine2_value); 8357 gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine3_uniform_location, 8358 ¤t_item.stage.default_subroutine3_value); 8359 gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine4_uniform_location, 8360 ¤t_item.stage.default_subroutine4_value); 8361 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformSubroutineuiv() call(s) failed."); 8362 8363 current_item.stage.gl_stage = current_item.so_type; 8364 8365 if (m_po_ids[n_id] != current_item.po_id) 8366 { 8367 /* Unbind the program pipeline object */ 8368 gl.bindProgramPipeline(0); 8369 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 8370 } 8371 } /* for (all items) */ 8372 8373 /* Make sure the default subroutine choices are valid. */ 8374 verifySubroutineUniformValues( 8375 TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, /* makes the verification routine use program object descriptor */ 8376 n_id, SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES); 8377 8378 if (m_are_pipeline_objects_supported) 8379 { 8380 gl.useProgram(0); 8381 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 8382 8383 gl.bindProgramPipeline(m_pipeline_object_ids[n_id]); 8384 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 8385 { 8386 verifySubroutineUniformValues( 8387 TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT, /* makes the verification routine use pipeline object descriptor */ 8388 n_id, SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES); 8389 } 8390 gl.bindProgramPipeline(0); 8391 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); 8392 } 8393 } /* for (both program descriptors) */ 8394 } 8395 8396 /** Retrieves IDs of shaders OR shader program objects, depending on which of the two 8397 * the caller requests for. 8398 * 8399 * @param retrieve_program_object_shader_ids true if the caller wishes to retrieve shader object IDs, 8400 * false to return shader program IDs. 8401 * @param n_id Index of the program/pipeline object the shaders 8402 * are a part of. 8403 * @param out_shader_stages Deref will be used to store exactly five IDs. Must not 8404 * be NULL. 8405 **/ 8406 void FunctionalTest16::getShaderStages(bool retrieve_program_object_shader_ids, const unsigned int& n_id, 8407 const _shader_stage** out_shader_stages) const 8408 { 8409 if (retrieve_program_object_shader_ids) 8410 { 8411 out_shader_stages[0] = &m_po_descriptors[n_id].vertex; 8412 out_shader_stages[1] = &m_po_descriptors[n_id].tess_control; 8413 out_shader_stages[2] = &m_po_descriptors[n_id].tess_evaluation; 8414 out_shader_stages[3] = &m_po_descriptors[n_id].geometry; 8415 out_shader_stages[4] = &m_po_descriptors[n_id].fragment; 8416 } 8417 else 8418 { 8419 out_shader_stages[0] = m_vs_po_descriptors + n_id; 8420 out_shader_stages[1] = m_tc_po_descriptors + n_id; 8421 out_shader_stages[2] = m_te_po_descriptors + n_id; 8422 out_shader_stages[3] = m_gs_po_descriptors + n_id; 8423 out_shader_stages[4] = m_fs_po_descriptors + n_id; 8424 } 8425 } 8426 8427 /** Executes test iteration. 8428 * 8429 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 8430 */ 8431 tcu::TestNode::IterateResult FunctionalTest16::iterate() 8432 { 8433 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 8434 8435 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 8436 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 8437 { 8438 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 8439 } 8440 8441 m_are_pipeline_objects_supported = 8442 m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects"); 8443 8444 /* Initialize GL objects required to run the test */ 8445 initTest(); 8446 8447 /* Iterate over both pipelines/programs and verify that calling glUseProgram() / 8448 * glBindProgramPipeline() / glUseProgramStages() resets subroutine uniform configuration. 8449 */ 8450 for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) 8451 { 8452 if (static_cast<_test_case>(test_case) != TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT && 8453 !m_are_pipeline_objects_supported) 8454 { 8455 /* Current test case requires GL_ARB_separate_shader_objects support which is 8456 * unavaiable on the platform that we're testing 8457 */ 8458 continue; 8459 } 8460 8461 for (unsigned int n_object_id = 0; n_object_id < 2; /* pipeline/program objects allocated for the test */ 8462 ++n_object_id) 8463 { 8464 /* Verify that currently reported subroutine uniform values are equal to default values */ 8465 if (test_case == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT) 8466 { 8467 gl.useProgram(m_po_ids[n_object_id]); 8468 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed"); 8469 } 8470 else 8471 { 8472 gl.bindProgramPipeline(m_pipeline_object_ids[n_object_id]); 8473 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed"); 8474 } 8475 8476 verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id, 8477 SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES); 8478 8479 /* Re-configure subroutine uniforms so that they point to different subroutines than 8480 * the default ones. 8481 */ 8482 const _shader_stage* stages[5 /* fs+gs+tc+te+vs */] = { DE_NULL }; 8483 8484 getShaderStages(static_cast<_test_case>(test_case) == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, 8485 n_object_id, stages); 8486 8487 for (unsigned int n_stage = 0; n_stage < 5 /* fs+gs+tc+te+vs stages */; ++n_stage) 8488 { 8489 const _shader_stage& current_stage = *(stages[n_stage]); 8490 glw::GLuint subroutine_configuration[4] = { GL_INVALID_INDEX }; 8491 8492 subroutine_configuration[0] = 8493 (current_stage.default_subroutine1_value == current_stage.function1_index) ? 8494 current_stage.function2_index : 8495 current_stage.function1_index; 8496 subroutine_configuration[1] = 8497 (current_stage.default_subroutine2_value == current_stage.function1_index) ? 8498 current_stage.function2_index : 8499 current_stage.function1_index; 8500 subroutine_configuration[2] = 8501 (current_stage.default_subroutine3_value == current_stage.function3_index) ? 8502 current_stage.function4_index : 8503 current_stage.function3_index; 8504 subroutine_configuration[3] = 8505 (current_stage.default_subroutine4_value == current_stage.function3_index) ? 8506 current_stage.function4_index : 8507 current_stage.function3_index; 8508 8509 gl.uniformSubroutinesuiv(current_stage.gl_stage, 4 /* count */, subroutine_configuration); 8510 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed."); 8511 } /* for (all stages) */ 8512 8513 verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id, 8514 SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES); 8515 8516 /* Execute test case-specific code */ 8517 _shader_stage cached_shader_stage_data; 8518 bool stage_reset_status[Utils::SHADER_STAGE_COUNT] = { false, false, false, false, false }; 8519 bool uses_stage_reset_status = false; 8520 8521 switch (test_case) 8522 { 8523 case TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT: 8524 { 8525 /* Switch to a different program object and then back to current PO. 8526 * Subroutine uniforms should be back at their default settings, instead of 8527 * the ones we've just set. 8528 */ 8529 gl.useProgram(m_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8530 gl.useProgram(m_po_ids[n_object_id]); 8531 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call(s) failed."); 8532 8533 break; 8534 } 8535 8536 case TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT: 8537 { 8538 /* Switch to a different pipeline object and then back to the current one. 8539 * Subroutine uniforms should be back at their default settings, instead of 8540 * the ones we've just set. 8541 */ 8542 gl.bindProgramPipeline( 8543 m_pipeline_object_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8544 gl.bindProgramPipeline(m_pipeline_object_ids[n_object_id]); 8545 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call(s) failed."); 8546 8547 break; 8548 } 8549 8550 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE: 8551 { 8552 /* Change the fragment shader stage to a different one. 8553 * 8554 * Note: We also need to update internal descriptor since the subroutine/uniform 8555 * locations may be different between the two programs. 8556 */ 8557 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_FRAGMENT_SHADER_BIT, 8558 m_fs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8559 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8560 8561 cached_shader_stage_data = m_fs_po_descriptors[n_object_id]; 8562 m_fs_po_descriptors[n_object_id] = m_fs_po_descriptors[(n_object_id + 1) % 2]; 8563 8564 stage_reset_status[Utils::SHADER_STAGE_FRAGMENT] = true; 8565 uses_stage_reset_status = true; 8566 8567 break; 8568 } 8569 8570 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE: 8571 { 8572 /* Change the geometry shader stage to a different one. 8573 * 8574 * Note: We also need to update internal descriptor since the subroutine/uniform 8575 * locations may be different between the two programs. 8576 */ 8577 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_GEOMETRY_SHADER_BIT, 8578 m_gs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8579 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8580 8581 cached_shader_stage_data = m_gs_po_descriptors[n_object_id]; 8582 m_gs_po_descriptors[n_object_id] = m_gs_po_descriptors[(n_object_id + 1) % 2]; 8583 8584 stage_reset_status[Utils::SHADER_STAGE_GEOMETRY] = true; 8585 uses_stage_reset_status = true; 8586 8587 break; 8588 } 8589 8590 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE: 8591 { 8592 /* Change the tessellation control shader stage to a different one. 8593 * 8594 * Note: We also need to update internal descriptor since the subroutine/uniform 8595 * locations may be different between the two programs. 8596 */ 8597 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_CONTROL_SHADER_BIT, 8598 m_tc_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8599 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8600 8601 cached_shader_stage_data = m_tc_po_descriptors[n_object_id]; 8602 m_tc_po_descriptors[n_object_id] = m_tc_po_descriptors[(n_object_id + 1) % 2]; 8603 8604 stage_reset_status[Utils::SHADER_STAGE_TESSELLATION_CONTROL] = true; 8605 uses_stage_reset_status = true; 8606 8607 break; 8608 } 8609 8610 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE: 8611 { 8612 /* Change the tessellation evaluation shader stage to a different one. 8613 * 8614 * Note: We also need to update internal descriptor since the subroutine/uniform 8615 * locations may be different between the two programs. 8616 */ 8617 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_EVALUATION_SHADER_BIT, 8618 m_te_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8619 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8620 8621 cached_shader_stage_data = m_te_po_descriptors[n_object_id]; 8622 m_te_po_descriptors[n_object_id] = m_te_po_descriptors[(n_object_id + 1) % 2]; 8623 8624 stage_reset_status[Utils::SHADER_STAGE_TESSELLATION_EVALUATION] = true; 8625 uses_stage_reset_status = true; 8626 8627 break; 8628 } 8629 8630 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE: 8631 { 8632 /* Change the vertex shader stage to a different one. 8633 * 8634 * Note: We also need to update internal descriptor since the subroutine/uniform 8635 * locations may be different between the two programs. 8636 */ 8637 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_VERTEX_SHADER_BIT, 8638 m_vs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); 8639 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8640 8641 cached_shader_stage_data = m_vs_po_descriptors[n_object_id]; 8642 m_vs_po_descriptors[n_object_id] = m_vs_po_descriptors[(n_object_id + 1) % 2]; 8643 8644 stage_reset_status[Utils::SHADER_STAGE_VERTEX] = true; 8645 uses_stage_reset_status = true; 8646 8647 break; 8648 } 8649 8650 default: 8651 { 8652 TCU_FAIL("Unrecognized test case"); 8653 } 8654 } /* switch (test_case) */ 8655 8656 /* Verify the subroutine uniform values are valid */ 8657 if (!uses_stage_reset_status) 8658 { 8659 verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id, 8660 SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES); 8661 } 8662 else 8663 { 8664 const _shader_stage* shader_stages[Utils::SHADER_STAGE_COUNT] = { DE_NULL }; 8665 8666 getShaderStages(static_cast<_test_case>(test_case) == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, 8667 n_object_id, shader_stages); 8668 8669 for (unsigned int n_shader_stage = 0; n_shader_stage < Utils::SHADER_STAGE_COUNT; ++n_shader_stage) 8670 { 8671 const _shader_stage& current_shader_stage = *(shader_stages[n_shader_stage]); 8672 8673 if (stage_reset_status[n_shader_stage]) 8674 { 8675 verifySubroutineUniformValuesForShaderStage(current_shader_stage, 8676 SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES); 8677 } 8678 else 8679 { 8680 verifySubroutineUniformValuesForShaderStage(current_shader_stage, 8681 SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES); 8682 } 8683 } /* for (all shader stages) */ 8684 } 8685 8686 /* Revert the changes some of the test cases appied */ 8687 switch (test_case) 8688 { 8689 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE: 8690 { 8691 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_FRAGMENT_SHADER_BIT, 8692 m_fs_po_ids[n_object_id]); 8693 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8694 8695 m_fs_po_descriptors[n_object_id] = cached_shader_stage_data; 8696 8697 break; 8698 } 8699 8700 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE: 8701 { 8702 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_GEOMETRY_SHADER_BIT, 8703 m_gs_po_ids[n_object_id]); 8704 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8705 8706 m_gs_po_descriptors[n_object_id] = cached_shader_stage_data; 8707 8708 break; 8709 } 8710 8711 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE: 8712 { 8713 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_CONTROL_SHADER_BIT, 8714 m_tc_po_ids[n_object_id]); 8715 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8716 8717 m_tc_po_descriptors[n_object_id] = cached_shader_stage_data; 8718 8719 break; 8720 } 8721 8722 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE: 8723 { 8724 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_EVALUATION_SHADER_BIT, 8725 m_te_po_ids[n_object_id]); 8726 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8727 8728 m_te_po_descriptors[n_object_id] = cached_shader_stage_data; 8729 8730 break; 8731 } 8732 8733 case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE: 8734 { 8735 gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_VERTEX_SHADER_BIT, m_vs_po_ids[n_object_id]); 8736 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); 8737 8738 m_vs_po_descriptors[n_object_id] = cached_shader_stage_data; 8739 8740 break; 8741 } 8742 8743 default: 8744 break; 8745 } /* switch (test_case) */ 8746 8747 } /* for (all program object descriptors) */ 8748 8749 /* Unbind the program object */ 8750 gl.useProgram(0); 8751 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 8752 } /* for (all test cases) */ 8753 8754 if (m_has_test_passed) 8755 { 8756 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 8757 } 8758 else 8759 { 8760 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 8761 } 8762 8763 return STOP; 8764 } 8765 8766 /** Verifies the subroutine uniform values reported by GL implementation. Depending on the test case, 8767 * it will either query program object stages or separate shader objects. 8768 * 8769 * @param test_case Test case the verification is to be performed for. 8770 * @param n_id Index of the program/pipeline object to use for the verification 8771 * @param verification Verification method. 8772 */ 8773 void FunctionalTest16::verifySubroutineUniformValues(const _test_case& test_case, const unsigned int& n_id, 8774 const _subroutine_uniform_value_verification& verification) 8775 { 8776 const _shader_stage* stages[] = { 8777 DE_NULL, /* fragment shader stage slot */ 8778 DE_NULL, /* geometry shader stage slot */ 8779 DE_NULL, /* tess control shader stage slot */ 8780 DE_NULL, /* tess eval shader stage slot */ 8781 DE_NULL /* vertex shader stage slot */ 8782 }; 8783 const unsigned int n_stages = sizeof(stages) / sizeof(stages[0]); 8784 8785 /* Verify that currently reported subroutine uniform values are equal to default values */ 8786 getShaderStages(test_case == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, n_id, stages); 8787 8788 for (unsigned int n_stage = 0; n_stage < n_stages; ++n_stage) 8789 { 8790 const _shader_stage& current_stage = *(stages[n_stage]); 8791 8792 verifySubroutineUniformValuesForShaderStage(current_stage, verification); 8793 } /* for (all items) */ 8794 } 8795 8796 /** Verifies the subroutine uniform values reported by GL implementation for user-specified 8797 * shader stage. If the verification fails, m_has_test_passed will be set to false. 8798 * 8799 * @param shader_stage Descriptor of a shader stage that should be used for the process. 8800 * @param verification Type of verification that should be performed. 8801 * 8802 **/ 8803 void FunctionalTest16::verifySubroutineUniformValuesForShaderStage( 8804 const _shader_stage& shader_stage, const _subroutine_uniform_value_verification& verification) 8805 { 8806 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 8807 glw::GLuint result_values[4] = { 0 }; 8808 8809 gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine1_uniform_location, result_values + 0); 8810 gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine2_uniform_location, result_values + 1); 8811 gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine3_uniform_location, result_values + 2); 8812 gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine4_uniform_location, result_values + 3); 8813 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformSubroutineuiv() call(s) failed."); 8814 8815 if (verification == SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES) 8816 { 8817 if (!((result_values[0] == (GLuint)shader_stage.subroutine1_uniform_location || 8818 result_values[0] == (GLuint)shader_stage.subroutine2_uniform_location) && 8819 (result_values[1] == (GLuint)shader_stage.subroutine1_uniform_location || 8820 result_values[1] == (GLuint)shader_stage.subroutine2_uniform_location) && 8821 (result_values[2] == (GLuint)shader_stage.subroutine3_uniform_location || 8822 result_values[2] == (GLuint)shader_stage.subroutine4_uniform_location) && 8823 (result_values[3] == (GLuint)shader_stage.subroutine3_uniform_location || 8824 result_values[3] == (GLuint)shader_stage.subroutine4_uniform_location))) 8825 { 8826 m_testCtx.getLog() << tcu::TestLog::Message << "SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES validation failed. " 8827 "Shader stage:[" 8828 << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], " 8829 "expected data:[" 8830 << shader_stage.subroutine1_uniform_location << " OR " 8831 << shader_stage.subroutine2_uniform_location << " x 2, " 8832 << shader_stage.subroutine3_uniform_location << " OR " 8833 << shader_stage.subroutine4_uniform_location << " x 2], " 8834 "found data:[" 8835 << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", " 8836 << result_values[3] << "]." << tcu::TestLog::EndMessage; 8837 8838 m_has_test_passed = false; 8839 } 8840 } 8841 else if (verification == SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES) 8842 { 8843 if (result_values[0] != shader_stage.default_subroutine1_value || 8844 result_values[1] != shader_stage.default_subroutine2_value || 8845 result_values[2] != shader_stage.default_subroutine3_value || 8846 result_values[3] != shader_stage.default_subroutine4_value) 8847 { 8848 m_testCtx.getLog() << tcu::TestLog::Message 8849 << "SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES validation failed. " 8850 "Shader stage:[" 8851 << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], " 8852 "expected data:[" 8853 << shader_stage.default_subroutine1_value << ", " 8854 << shader_stage.default_subroutine2_value << ", " 8855 << shader_stage.default_subroutine3_value << ", " 8856 << shader_stage.default_subroutine4_value << "], " 8857 "found data:[" 8858 << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", " 8859 << result_values[3] << "]." << tcu::TestLog::EndMessage; 8860 8861 m_has_test_passed = false; 8862 } 8863 } 8864 else 8865 { 8866 DE_ASSERT(verification == SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES); 8867 8868 if (result_values[0] == shader_stage.default_subroutine1_value || 8869 result_values[1] == shader_stage.default_subroutine2_value || 8870 result_values[2] == shader_stage.default_subroutine3_value || 8871 result_values[3] == shader_stage.default_subroutine4_value) 8872 { 8873 m_testCtx.getLog() << tcu::TestLog::Message 8874 << "SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES validation failed. " 8875 "Shader stage:[" 8876 << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], " 8877 "expected data:![" 8878 << shader_stage.default_subroutine1_value << ", " 8879 << shader_stage.default_subroutine2_value << ", " 8880 << shader_stage.default_subroutine3_value << ", " 8881 << shader_stage.default_subroutine4_value << "], " 8882 "found data:[" 8883 << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", " 8884 << result_values[3] << "]." << tcu::TestLog::EndMessage; 8885 8886 m_has_test_passed = false; 8887 } 8888 } 8889 } 8890 8891 /** Constructor. 8892 * 8893 * @param context Rendering context. 8894 * 8895 **/ 8896 FunctionalTest17::FunctionalTest17(deqp::Context& context) 8897 : TestCase(context, "same_subroutine_and_subroutine_uniform_but_different_type_used_in_all_stages", 8898 "Creates a program which uses the same subroutine and subroutine uniform " 8899 "names for every stage (types of subroutines are different in each stage) " 8900 "and then makes sure that such program compiles and works as expected.") 8901 , m_fbo_id(0) 8902 , m_fs_id(0) 8903 , m_gs_id(0) 8904 , m_has_test_passed(true) 8905 , m_po_id(0) 8906 , m_tc_id(0) 8907 , m_te_id(0) 8908 , m_to_data(DE_NULL) 8909 , m_to_height(4) /* arbitrary value */ 8910 , m_to_id(0) 8911 , m_to_width(4) /* arbitrary value */ 8912 , m_vao_id(0) 8913 , m_vs_id(0) 8914 { 8915 /* Left blank intentionally */ 8916 } 8917 8918 /** Deinitializes all GL objects that may have been created during test execution. */ 8919 void FunctionalTest17::deinit() 8920 { 8921 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 8922 8923 if (m_fbo_id != 0) 8924 { 8925 gl.deleteFramebuffers(1, &m_fbo_id); 8926 8927 m_fbo_id = 0; 8928 } 8929 8930 if (m_fs_id != 0) 8931 { 8932 gl.deleteShader(m_fs_id); 8933 8934 m_fs_id = 0; 8935 } 8936 8937 if (m_gs_id != 0) 8938 { 8939 gl.deleteShader(m_gs_id); 8940 8941 m_gs_id = 0; 8942 } 8943 8944 if (m_po_id != 0) 8945 { 8946 gl.deleteProgram(m_po_id); 8947 8948 m_po_id = 0; 8949 } 8950 8951 if (m_tc_id != 0) 8952 { 8953 gl.deleteShader(m_tc_id); 8954 8955 m_tc_id = 0; 8956 } 8957 8958 if (m_te_id != 0) 8959 { 8960 gl.deleteShader(m_te_id); 8961 8962 m_te_id = 0; 8963 } 8964 8965 if (m_to_data != DE_NULL) 8966 { 8967 delete[] m_to_data; 8968 8969 m_to_data = DE_NULL; 8970 } 8971 8972 if (m_to_id != 0) 8973 { 8974 gl.deleteTextures(1, &m_to_id); 8975 8976 m_to_id = 0; 8977 } 8978 8979 if (m_vao_id != 0) 8980 { 8981 gl.deleteVertexArrays(1, &m_vao_id); 8982 8983 m_vao_id = 0; 8984 } 8985 8986 if (m_vs_id != 0) 8987 { 8988 gl.deleteShader(m_vs_id); 8989 8990 m_vs_id = 0; 8991 } 8992 8993 /* Restore original GL configuration */ 8994 gl.patchParameteri(GL_PATCH_VERTICES, 3); 8995 GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed."); 8996 8997 gl.pixelStorei(GL_PACK_ALIGNMENT, 4); 8998 GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed."); 8999 } 9000 9001 /** Retrieves body of a fragment shader that should be used by the test program. 9002 * 9003 * @return Requested string. 9004 **/ 9005 std::string FunctionalTest17::getFragmentShaderBody() const 9006 { 9007 return "#version 400\n" 9008 "\n" 9009 "#extension GL_ARB_shader_subroutine : require\n" 9010 "\n" 9011 "in GS_DATA\n" 9012 "{\n" 9013 " vec4 gs_data;\n" 9014 " vec4 tc_data;\n" 9015 " vec4 te_data;\n" 9016 " vec4 vs_data;\n" 9017 "} gs;\n" 9018 "\n" 9019 "out vec4 result;\n" 9020 "\n" 9021 "subroutine void subroutineTypeFS(out vec4 result);\n" 9022 "\n" 9023 "subroutine(subroutineTypeFS) void subroutine1(out vec4 result)\n" 9024 "{\n" 9025 " result = vec4(5, 6, 7, 8);\n" 9026 "}\n" 9027 "\n" 9028 "subroutine uniform subroutineTypeFS function;\n" 9029 "\n" 9030 "void main()\n" 9031 "{\n" 9032 " vec4 fs_data;\n" 9033 "\n" 9034 " function(fs_data);\n" 9035 " result = gs.gs_data + gs.tc_data + gs.te_data + gs.vs_data + fs_data;\n" 9036 "}\n"; 9037 } 9038 9039 /** Retrieves body of a geometry shader that should be used by the test program. 9040 * 9041 * @return Requested string. 9042 **/ 9043 std::string FunctionalTest17::getGeometryShaderBody() const 9044 { 9045 return "#version 400\n" 9046 "\n" 9047 "#extension GL_ARB_shader_subroutine : require\n" 9048 "\n" 9049 "layout(points) in;\n" 9050 "layout(triangle_strip, max_vertices = 4) out;\n" 9051 "\n" 9052 "subroutine void subroutineTypeGS(out vec4 result);\n" 9053 "\n" 9054 "subroutine(subroutineTypeGS) void subroutine1(out vec4 result)\n" 9055 "{\n" 9056 " result = vec4(4, 5, 6, 7);\n" 9057 "}\n" 9058 "\n" 9059 "subroutine uniform subroutineTypeGS function;\n" 9060 "\n" 9061 "in TE_DATA\n" 9062 "{\n" 9063 " vec4 tc_data;\n" 9064 " vec4 te_data;\n" 9065 " vec4 vs_data;\n" 9066 "} te[];\n" 9067 "\n" 9068 "out GS_DATA\n" 9069 "{\n" 9070 " vec4 gs_data;\n" 9071 " vec4 tc_data;\n" 9072 " vec4 te_data;\n" 9073 " vec4 vs_data;\n" 9074 "} result;\n" 9075 "\n" 9076 "void main()\n" 9077 "{\n" 9078 " function(result.gs_data);\n" 9079 " gl_Position = vec4(1, -1, 0, 1);\n" 9080 " result.tc_data = te[0].tc_data;\n" 9081 " result.te_data = te[0].te_data;\n" 9082 " result.vs_data = te[0].vs_data;\n" 9083 " EmitVertex();\n" 9084 "\n" 9085 " function(result.gs_data);\n" 9086 " gl_Position = vec4(-1, -1, 0, 1);\n" 9087 " result.tc_data = te[0].tc_data;\n" 9088 " result.te_data = te[0].te_data;\n" 9089 " result.vs_data = te[0].vs_data;\n" 9090 " EmitVertex();\n" 9091 "\n" 9092 " function(result.gs_data);\n" 9093 " gl_Position = vec4(1, 1, 0, 1);\n" 9094 " result.tc_data = te[0].tc_data;\n" 9095 " result.te_data = te[0].te_data;\n" 9096 " result.vs_data = te[0].vs_data;\n" 9097 " EmitVertex();\n" 9098 "\n" 9099 " function(result.gs_data);\n" 9100 " gl_Position = vec4(-1, 1, 0, 1);\n" 9101 " result.tc_data = te[0].tc_data;\n" 9102 " result.te_data = te[0].te_data;\n" 9103 " result.vs_data = te[0].vs_data;\n" 9104 " EmitVertex();\n" 9105 " EndPrimitive();\n" 9106 "}\n"; 9107 } 9108 9109 /** Retrieves body of a tessellation control shader that should be used by the test program. 9110 * 9111 * @return Requested string. 9112 **/ 9113 std::string FunctionalTest17::getTessellationControlShaderBody() const 9114 { 9115 return "#version 400\n" 9116 "\n" 9117 "#extension GL_ARB_shader_subroutine : require\n" 9118 "\n" 9119 "layout (vertices = 4) out;\n" 9120 "\n" 9121 "subroutine void subroutineTypeTC(out vec4 result);\n" 9122 "\n" 9123 "subroutine(subroutineTypeTC) void subroutine1(out vec4 result)\n" 9124 "{\n" 9125 " result = vec4(2, 3, 4, 5);\n" 9126 "}\n" 9127 "\n" 9128 "subroutine uniform subroutineTypeTC function;\n" 9129 "\n" 9130 "in VS_DATA\n" 9131 "{\n" 9132 " vec4 vs_data;\n" 9133 "} vs[];\n" 9134 "\n" 9135 "out TC_DATA\n" 9136 "{\n" 9137 " vec4 tc_data;\n" 9138 " vec4 vs_data;\n" 9139 "} result[];\n" 9140 "\n" 9141 "void main()\n" 9142 "{\n" 9143 " gl_TessLevelInner[0] = 1.0;\n" 9144 " gl_TessLevelInner[1] = 1.0;\n" 9145 " gl_TessLevelOuter[0] = 1.0;\n" 9146 " gl_TessLevelOuter[1] = 1.0;\n" 9147 " gl_TessLevelOuter[2] = 1.0;\n" 9148 " gl_TessLevelOuter[3] = 1.0;\n" 9149 "\n" 9150 " function(result[gl_InvocationID].tc_data);\n" 9151 " result[gl_InvocationID].vs_data = vs[gl_InvocationID].vs_data;\n" 9152 "}\n"; 9153 } 9154 9155 /** Retrieves body of a tessellation evaluation shader that should be used 9156 * by the test program. 9157 * 9158 * @return Requested string. 9159 **/ 9160 std::string FunctionalTest17::getTessellationEvaluationShaderBody() const 9161 { 9162 return "#version 400\n" 9163 "\n" 9164 "#extension GL_ARB_shader_subroutine : require\n" 9165 "\n" 9166 "layout (quads, point_mode) in;\n" 9167 "\n" 9168 "subroutine void subroutineTypeTE(out vec4 result);\n" 9169 "\n" 9170 "subroutine(subroutineTypeTE) void subroutine1(out vec4 result)\n" 9171 "{\n" 9172 " result = vec4(3, 4, 5, 6);\n" 9173 "}\n" 9174 "\n" 9175 "subroutine uniform subroutineTypeTE function;\n" 9176 "\n" 9177 "in TC_DATA\n" 9178 "{\n" 9179 " vec4 tc_data;\n" 9180 " vec4 vs_data;\n" 9181 "} tc[];\n" 9182 "\n" 9183 "out TE_DATA\n" 9184 "{\n" 9185 " vec4 tc_data;\n" 9186 " vec4 te_data;\n" 9187 " vec4 vs_data;\n" 9188 "} result;\n" 9189 "\n" 9190 "void main()\n" 9191 "{\n" 9192 " result.vs_data = tc[0].vs_data;\n" 9193 " result.tc_data = tc[0].tc_data;\n" 9194 " function(result.te_data);\n" 9195 "}\n"; 9196 } 9197 9198 /** Retrieves body of a vertex shader that should be used by the test program. 9199 * 9200 * @return Requested string. 9201 **/ 9202 std::string FunctionalTest17::getVertexShaderBody() const 9203 { 9204 return "#version 400\n" 9205 "\n" 9206 "#extension GL_ARB_shader_subroutine : require\n" 9207 "\n" 9208 "out VS_DATA\n" 9209 "{\n" 9210 " vec4 vs_data;\n" 9211 "} result;\n" 9212 "\n" 9213 "subroutine void subroutineTypeVS(out vec4 result);\n" 9214 "\n" 9215 "subroutine(subroutineTypeVS) void subroutine1(out vec4 result)\n" 9216 "{\n" 9217 " result = vec4(1, 2, 3, 4);\n" 9218 "}\n" 9219 "\n" 9220 "subroutine uniform subroutineTypeVS function;\n" 9221 "\n" 9222 "void main()\n" 9223 "{\n" 9224 " function(result.vs_data);\n" 9225 "}\n"; 9226 } 9227 9228 /** Initializes all buffers and GL objects required to run the test. */ 9229 void FunctionalTest17::initTest() 9230 { 9231 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9232 9233 /* Configure GL_PATCH_VERTICES so that TC only takes a single patch vertex */ 9234 gl.patchParameteri(GL_PATCH_VERTICES, 1); 9235 GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed."); 9236 9237 /* Generate & bind a VAO */ 9238 gl.genVertexArrays(1, &m_vao_id); 9239 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 9240 9241 gl.bindVertexArray(m_vao_id); 9242 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 9243 9244 /* Set up test program object */ 9245 std::string fs_body = getFragmentShaderBody(); 9246 std::string gs_body = getGeometryShaderBody(); 9247 std::string tc_body = getTessellationControlShaderBody(); 9248 std::string te_body = getTessellationEvaluationShaderBody(); 9249 std::string vs_body = getVertexShaderBody(); 9250 9251 if (!Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, DE_NULL, /* xfb_varyings */ 9252 DE_NULL, /* n_xfb_varyings */ 9253 &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) 9254 { 9255 TCU_FAIL("Failed to link test program object"); 9256 } 9257 9258 /* Set up a texture object that will be used as a color attachment */ 9259 gl.genTextures(1, &m_to_id); 9260 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); 9261 9262 gl.bindTexture(GL_TEXTURE_2D, m_to_id); 9263 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); 9264 9265 gl.texStorage2D(GL_TEXTURE_2D, 1, /* levels */ 9266 GL_RGBA32F, m_to_width, m_to_height); 9267 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed."); 9268 9269 /* Set up FBO */ 9270 gl.genFramebuffers(1, &m_fbo_id); 9271 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed."); 9272 9273 gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); 9274 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed."); 9275 9276 gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */); 9277 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed."); 9278 9279 /* Make sure glReadPixels() does not return misaligned data */ 9280 gl.pixelStorei(GL_PACK_ALIGNMENT, 1); 9281 GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed."); 9282 9283 /* Initialize a buffer that will be used to store rendered data */ 9284 m_to_data = new float[m_to_width * m_to_height * 4 /* rgba */]; 9285 } 9286 9287 /** Executes test iteration. 9288 * 9289 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 9290 */ 9291 tcu::TestNode::IterateResult FunctionalTest17::iterate() 9292 { 9293 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9294 9295 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 9296 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 9297 { 9298 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 9299 } 9300 9301 initTest(); 9302 9303 /* Use the test program to render a full-screen test quad */ 9304 gl.useProgram(m_po_id); 9305 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 9306 9307 gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */); 9308 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 9309 9310 /* Read back the data that was rendered */ 9311 gl.readPixels(0, /* x */ 9312 0, /* y */ 9313 m_to_width, m_to_height, GL_RGBA, GL_FLOAT, m_to_data); 9314 GLU_EXPECT_NO_ERROR(gl.getError(), "glReaDPixels() call failed."); 9315 9316 /* Verify the data */ 9317 verifyRenderedData(); 9318 9319 /** All done */ 9320 if (m_has_test_passed) 9321 { 9322 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 9323 } 9324 else 9325 { 9326 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 9327 } 9328 9329 return STOP; 9330 } 9331 9332 /** Verifies the data that have been rendered by the test program. 9333 * 9334 * It is assumed the rendered data have already been copied to 9335 * m_to_data. 9336 * 9337 * If the rendered data is found to be invalid, m_has_test_passed 9338 * will be set to false. 9339 **/ 9340 void FunctionalTest17::verifyRenderedData() 9341 { 9342 const float epsilon = 1e-5f; 9343 const float expected_data[4] = { 15.0f, 20.0f, 25.0f, 30.0f }; 9344 9345 for (unsigned int y = 0; y < m_to_height && m_has_test_passed; ++y) 9346 { 9347 const float* row_ptr = m_to_data + y * 4 /* rgba */ * m_to_width; 9348 9349 for (unsigned int x = 0; x < m_to_width && m_has_test_passed; ++x) 9350 { 9351 const float* pixel_ptr = row_ptr + 4 /* rgba */ * x; 9352 9353 if (de::abs(pixel_ptr[0] - expected_data[0]) > epsilon || 9354 de::abs(pixel_ptr[1] - expected_data[1]) > epsilon || 9355 de::abs(pixel_ptr[2] - expected_data[2]) > epsilon || 9356 de::abs(pixel_ptr[3] - expected_data[3]) > epsilon) 9357 { 9358 m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel found at (" << x << ", " << y 9359 << "): " 9360 "expected:(" 9361 << expected_data[0] << ", " << expected_data[1] << ", " << expected_data[2] << ", " 9362 << expected_data[3] << "), found:(" << pixel_ptr[0] << ", " << pixel_ptr[1] << ", " 9363 << pixel_ptr[2] << ", " << pixel_ptr[3] << ")." << tcu::TestLog::EndMessage; 9364 9365 m_has_test_passed = false; 9366 } 9367 } /* for (all columns) */ 9368 } /* for (all rows) */ 9369 } 9370 9371 /** Constructor. 9372 * 9373 * @param context Rendering context. 9374 * 9375 **/ 9376 FunctionalTest18_19::FunctionalTest18_19(deqp::Context& context) 9377 : TestCase(context, "control_flow_and_returned_subroutine_values_used_as_subroutine_input", 9378 "Makes sure that calling a subroutine with argument value returned by " 9379 "another subroutine works correctly. Also checks that subroutine and " 9380 "subroutine uniforms work as expected when used in connection with control " 9381 "flow functions.") 9382 , m_has_test_passed(true) 9383 , m_n_points_to_draw(16) /* arbitrary value */ 9384 , m_po_id(0) 9385 , m_po_subroutine_divide_by_two_location(GL_INVALID_INDEX) 9386 , m_po_subroutine_multiply_by_four_location(GL_INVALID_INDEX) 9387 , m_po_subroutine_returns_false_location(GL_INVALID_INDEX) 9388 , m_po_subroutine_returns_true_location(GL_INVALID_INDEX) 9389 , m_po_subroutine_uniform_bool_operator1(-1) 9390 , m_po_subroutine_uniform_bool_operator2(-1) 9391 , m_po_subroutine_uniform_vec4_processor1(-1) 9392 , m_po_subroutine_uniform_vec4_processor2(-1) 9393 , m_xfb_bo_id(0) 9394 , m_vao_id(0) 9395 , m_vs_id(0) 9396 { 9397 /* Left blank intentionally */ 9398 } 9399 9400 /** De-initializes all GL objects that may have been created during test execution */ 9401 void FunctionalTest18_19::deinit() 9402 { 9403 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9404 9405 if (m_po_id != 0) 9406 { 9407 gl.deleteProgram(m_po_id); 9408 9409 m_po_id = 0; 9410 } 9411 9412 if (m_vao_id != 0) 9413 { 9414 gl.deleteVertexArrays(1, &m_vao_id); 9415 9416 m_vao_id = 0; 9417 } 9418 9419 if (m_vs_id != 0) 9420 { 9421 gl.deleteShader(m_vs_id); 9422 9423 m_vs_id = 0; 9424 } 9425 9426 if (m_xfb_bo_id != 0) 9427 { 9428 gl.deleteBuffers(1, &m_xfb_bo_id); 9429 9430 m_xfb_bo_id = 0; 9431 } 9432 } 9433 9434 /** Executes a single test iteration using user-specified properties. If the 9435 * iterations fails, m_has_test_passed is set to false. 9436 * 9437 * @param bool_operator1_subroutine_location Location of a subroutine to be assigned to 9438 * bool_operator1 subroutine uniform. 9439 * @param bool_operator2_subroutine_location Location of a subroutine to be assigned to 9440 * bool_operator2 subroutine uniform. 9441 * @param vec4_operator1_subroutine_location Location of a subroutine to be assigned to 9442 * vec4_operator1 subroutine uniform. 9443 * @param vec4_operator2_subroutine_location Location of a subroutine to be assigned to 9444 * vec4_operator2 subroutine uniform. 9445 &**/ 9446 void FunctionalTest18_19::executeTest(glw::GLuint bool_operator1_subroutine_location, 9447 glw::GLuint bool_operator2_subroutine_location, 9448 glw::GLuint vec4_operator1_subroutine_location, 9449 glw::GLuint vec4_operator2_subroutine_location) 9450 { 9451 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9452 9453 /* Set up subroutines */ 9454 glw::GLuint subroutine_configuration[4 /* total number of subroutines */] = { 0 }; 9455 9456 subroutine_configuration[m_po_subroutine_uniform_bool_operator1] = bool_operator1_subroutine_location; 9457 subroutine_configuration[m_po_subroutine_uniform_bool_operator2] = bool_operator2_subroutine_location; 9458 subroutine_configuration[m_po_subroutine_uniform_vec4_processor1] = vec4_operator1_subroutine_location; 9459 subroutine_configuration[m_po_subroutine_uniform_vec4_processor2] = vec4_operator2_subroutine_location; 9460 9461 gl.useProgram(m_po_id); 9462 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed"); 9463 9464 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 4 /* count */, subroutine_configuration); 9465 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed"); 9466 9467 /* Draw test-specific number of points */ 9468 gl.beginTransformFeedback(GL_POINTS); 9469 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed"); 9470 { 9471 gl.drawArrays(GL_POINTS, 0 /* first */, m_n_points_to_draw); 9472 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed"); 9473 } 9474 gl.endTransformFeedback(); 9475 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed"); 9476 9477 /* Map the BO storage into process space */ 9478 const glw::GLvoid* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); 9479 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); 9480 9481 verifyXFBData(xfb_data_ptr, bool_operator1_subroutine_location, bool_operator2_subroutine_location, 9482 vec4_operator1_subroutine_location, vec4_operator2_subroutine_location); 9483 9484 /* Unmap BO storage */ 9485 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); 9486 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); 9487 } 9488 9489 /** Retrieves body of a vertex shader to be used by the test. */ 9490 std::string FunctionalTest18_19::getVertexShaderBody() const 9491 { 9492 return "#version 400\n" 9493 "\n" 9494 "subroutine bool bool_processor();\n" 9495 "subroutine vec4 vec4_processor(in vec4 iparam);\n" 9496 "\n" 9497 "subroutine(bool_processor) bool returnsFalse()\n" 9498 "{\n" 9499 " return false;\n" 9500 "}\n" 9501 "\n" 9502 "subroutine(bool_processor) bool returnsTrue()\n" 9503 "{\n" 9504 " return true;\n" 9505 "}\n" 9506 "\n" 9507 "subroutine(vec4_processor) vec4 divideByTwo(in vec4 iparam)\n" 9508 "{\n" 9509 " return iparam * vec4(0.5);\n" 9510 "}\n" 9511 "\n" 9512 "subroutine(vec4_processor) vec4 multiplyByFour(in vec4 iparam)\n" 9513 "{\n" 9514 " return iparam * vec4(4.0);\n" 9515 "}\n" 9516 "\n" 9517 "subroutine uniform bool_processor bool_operator1;\n" 9518 "subroutine uniform bool_processor bool_operator2;\n" 9519 "subroutine uniform vec4_processor vec4_operator1;\n" 9520 "subroutine uniform vec4_processor vec4_operator2;\n" 9521 "\n" 9522 "out float result;\n" 9523 "\n" 9524 "void main()\n" 9525 "{\n" 9526 " if (bool_operator1() )\n" 9527 " {\n" 9528 " float value = float( (3 * gl_VertexID + 1) * 2);\n" 9529 "\n" 9530 " while (bool_operator1() )\n" 9531 " {\n" 9532 " value /= float(gl_VertexID + 2);\n" 9533 "\n" 9534 " if (value <= 1.0f) break;\n" 9535 " }\n" 9536 "\n" 9537 " result = value;\n" 9538 " }\n" 9539 " else\n" 9540 " {\n" 9541 " vec4 value = vec4(gl_VertexID, gl_VertexID + 1,\n" 9542 " gl_VertexID + 2, gl_VertexID + 3);\n" 9543 "\n" 9544 " switch (gl_VertexID % 2)\n" 9545 " {\n" 9546 " case 0:\n" 9547 " {\n" 9548 " for (int iteration = 0; iteration < gl_VertexID && bool_operator2(); ++iteration)\n" 9549 " {\n" 9550 " value = vec4_operator2(vec4_operator1(value));\n" 9551 " }\n" 9552 "\n" 9553 " break;\n" 9554 " }\n" 9555 "\n" 9556 " case 1:\n" 9557 " {\n" 9558 " for (int iteration = 0; iteration < gl_VertexID * 2; ++iteration)\n" 9559 " {\n" 9560 " value = vec4_operator1(vec4_operator2(value));\n" 9561 " }\n" 9562 "\n" 9563 " break;\n" 9564 " }\n" 9565 " }\n" 9566 "\n" 9567 " result = value.x + value.y + value.z + value.w;\n" 9568 "\n" 9569 " }\n" 9570 "}\n"; 9571 } 9572 9573 /** Initializes all GL objects required to run the test. */ 9574 void FunctionalTest18_19::initTest() 9575 { 9576 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9577 const char* varyings[1] = { "result" }; 9578 std::string vs_body = getVertexShaderBody(); 9579 const unsigned int n_varyings = sizeof(varyings) / sizeof(varyings[0]); 9580 9581 if (!Utils::buildProgram(gl, vs_body, "", /* tc_body */ 9582 "", /* te_body */ 9583 "", /* gs_body */ 9584 "", /* fs_body */ 9585 varyings, n_varyings, &m_vs_id, DE_NULL, /* out_tc_id */ 9586 DE_NULL, /* out_te_id */ 9587 DE_NULL, /* out_gs_id */ 9588 DE_NULL, /* out_fs_id */ 9589 &m_po_id)) 9590 { 9591 TCU_FAIL("Failed to build test program object"); 9592 } 9593 9594 /* Retrieve subroutine & subroutine uniform locations */ 9595 m_po_subroutine_divide_by_two_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "divideByTwo"); 9596 m_po_subroutine_multiply_by_four_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "multiplyByFour"); 9597 m_po_subroutine_returns_false_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "returnsFalse"); 9598 m_po_subroutine_returns_true_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "returnsTrue"); 9599 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed"); 9600 9601 if (m_po_subroutine_divide_by_two_location == GL_INVALID_INDEX || 9602 m_po_subroutine_multiply_by_four_location == GL_INVALID_INDEX || 9603 m_po_subroutine_returns_false_location == GL_INVALID_INDEX || 9604 m_po_subroutine_returns_true_location == GL_INVALID_INDEX) 9605 { 9606 TCU_FAIL("glGetSubroutineIndex() returned GL_INVALID_INDEX for a valid subroutine"); 9607 } 9608 9609 m_po_subroutine_uniform_bool_operator1 = 9610 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "bool_operator1"); 9611 m_po_subroutine_uniform_bool_operator2 = 9612 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "bool_operator2"); 9613 m_po_subroutine_uniform_vec4_processor1 = 9614 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "vec4_operator1"); 9615 m_po_subroutine_uniform_vec4_processor2 = 9616 gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "vec4_operator2"); 9617 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed"); 9618 9619 if (m_po_subroutine_uniform_bool_operator1 == -1 || m_po_subroutine_uniform_bool_operator2 == -1 || 9620 m_po_subroutine_uniform_vec4_processor1 == -1 || m_po_subroutine_uniform_vec4_processor2 == -1) 9621 { 9622 TCU_FAIL("glGetSubroutineUniformLocation() returned -1 for an active subroutine uniform"); 9623 } 9624 9625 /* Set up XFB BO */ 9626 const unsigned int bo_size = static_cast<unsigned int>(sizeof(float) * m_n_points_to_draw); 9627 9628 gl.genBuffers(1, &m_xfb_bo_id); 9629 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); 9630 9631 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id); 9632 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); 9633 9634 gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id); 9635 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); 9636 9637 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, bo_size, DE_NULL /* data */, GL_STATIC_COPY); 9638 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); 9639 9640 /* Set up a VAO */ 9641 gl.genVertexArrays(1, &m_vao_id); 9642 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 9643 9644 gl.bindVertexArray(m_vao_id); 9645 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 9646 } 9647 9648 /** Executes test iteration. 9649 * 9650 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 9651 */ 9652 tcu::TestNode::IterateResult FunctionalTest18_19::iterate() 9653 { 9654 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 9655 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 9656 { 9657 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 9658 } 9659 9660 /* Initialize all GL objects required to run the test */ 9661 initTest(); 9662 9663 /* Iterate over all subroutine permutations */ 9664 const glw::GLuint subroutine_bool_operators[] = { m_po_subroutine_returns_false_location, 9665 m_po_subroutine_returns_true_location }; 9666 const unsigned int n_subroutine_bool_operators = 9667 sizeof(subroutine_bool_operators) / sizeof(subroutine_bool_operators[0]); 9668 9669 const glw::GLuint subroutine_vec4_operators[] = { m_po_subroutine_divide_by_two_location, 9670 m_po_subroutine_multiply_by_four_location }; 9671 const unsigned int n_subroutine_vec4_operators = 9672 sizeof(subroutine_vec4_operators) / sizeof(subroutine_vec4_operators[0]); 9673 9674 for (unsigned int n_subroutine_uniform_bool_operator1 = 0; 9675 n_subroutine_uniform_bool_operator1 < n_subroutine_bool_operators; ++n_subroutine_uniform_bool_operator1) 9676 { 9677 for (unsigned int n_subroutine_uniform_bool_operator2 = 0; 9678 n_subroutine_uniform_bool_operator2 < n_subroutine_bool_operators; ++n_subroutine_uniform_bool_operator2) 9679 { 9680 for (unsigned int n_subroutine_uniform_vec4_operator1 = 0; 9681 n_subroutine_uniform_vec4_operator1 < n_subroutine_vec4_operators; 9682 ++n_subroutine_uniform_vec4_operator1) 9683 { 9684 for (unsigned int n_subroutine_uniform_vec4_operator2 = 0; 9685 n_subroutine_uniform_vec4_operator2 < n_subroutine_vec4_operators; 9686 ++n_subroutine_uniform_vec4_operator2) 9687 { 9688 executeTest(subroutine_bool_operators[n_subroutine_uniform_bool_operator1], 9689 subroutine_bool_operators[n_subroutine_uniform_bool_operator2], 9690 subroutine_vec4_operators[n_subroutine_uniform_vec4_operator1], 9691 subroutine_vec4_operators[n_subroutine_uniform_vec4_operator2]); 9692 } /* for (all subroutine vec4 operator subroutines used for processor2) */ 9693 } /* for (all subroutine vec4 operator subroutines used for processor1) */ 9694 } /* for (all subroutine bool operator subroutines used for operator2) */ 9695 } /* for (all subroutine bool operator subroutines used for operator1) */ 9696 9697 /* All done */ 9698 if (m_has_test_passed) 9699 { 9700 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 9701 } 9702 else 9703 { 9704 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 9705 } 9706 9707 return STOP; 9708 } 9709 9710 /** Divides input argument by two. The result value is returned to the 9711 * caller. 9712 * 9713 * @param data Input value. 9714 * 9715 * @return As per description. 9716 **/ 9717 tcu::Vec4 FunctionalTest18_19::vec4operator_div2(tcu::Vec4 data) 9718 { 9719 return data * 0.5f; 9720 } 9721 9722 /** Multiplies input argument by four. The result value is returned to the 9723 * caller. 9724 * 9725 * @param data Input value. 9726 * 9727 * @return As per description. 9728 **/ 9729 tcu::Vec4 FunctionalTest18_19::vec4operator_mul4(tcu::Vec4 data) 9730 { 9731 return data * 4.0f; 9732 } 9733 9734 /** Verifies data XFBed out by the vertex shader. It is assumed the subroutines were configured 9735 * as per passed arguments, prior to the draw call. 9736 * 9737 * If the result data is found to be invalid, m_has_test_passed is set to false. 9738 * 9739 * @param data XFBed data. 9740 * @param bool_operator1_subroutine_location Location of a subroutine to be assigned to 9741 * bool_operator1 subroutine uniform. 9742 * @param bool_operator2_subroutine_location Location of a subroutine to be assigned to 9743 * bool_operator2 subroutine uniform. 9744 * @param vec4_operator1_subroutine_location Location of a subroutine to be assigned to 9745 * vec4_operator1 subroutine uniform. 9746 * @param vec4_operator2_subroutine_location Location of a subroutine to be assigned to 9747 * vec4_operator2 subroutine uniform. 9748 */ 9749 void FunctionalTest18_19::verifyXFBData(const glw::GLvoid* data, glw::GLuint bool_operator1_subroutine_location, 9750 glw::GLuint bool_operator2_subroutine_location, 9751 glw::GLuint vec4_operator1_subroutine_location, 9752 glw::GLuint vec4_operator2_subroutine_location) 9753 { 9754 bool bool_operator1_result = false; 9755 bool bool_operator2_result = false; 9756 const float epsilon = 1e-5f; 9757 PFNVEC4OPERATORPROC pVec4Operator1 = NULL; 9758 PFNVEC4OPERATORPROC pVec4Operator2 = NULL; 9759 const glw::GLfloat* traveller_ptr = (const glw::GLfloat*)data; 9760 9761 bool_operator1_result = (bool_operator1_subroutine_location == m_po_subroutine_returns_true_location); 9762 bool_operator2_result = (bool_operator2_subroutine_location == m_po_subroutine_returns_true_location); 9763 pVec4Operator1 = (vec4_operator1_subroutine_location == m_po_subroutine_divide_by_two_location) ? 9764 vec4operator_div2 : 9765 vec4operator_mul4; 9766 pVec4Operator2 = (vec4_operator2_subroutine_location == m_po_subroutine_divide_by_two_location) ? 9767 vec4operator_div2 : 9768 vec4operator_mul4; 9769 9770 for (unsigned int n_vertex = 0; n_vertex < m_n_points_to_draw; ++n_vertex) 9771 { 9772 float expected_value = 0.0f; 9773 9774 if (bool_operator1_result) 9775 { 9776 float value = float((3 * n_vertex + 1) * 2); 9777 9778 while (bool_operator1_result) 9779 { 9780 value /= float(n_vertex + 2); 9781 9782 if (value <= 1.0f) 9783 break; 9784 } 9785 9786 expected_value = value; 9787 } 9788 else 9789 { 9790 tcu::Vec4 value((float)n_vertex, (float)n_vertex + 1, (float)n_vertex + 2, (float)n_vertex + 3); 9791 9792 switch (n_vertex % 2) 9793 { 9794 case 0: 9795 { 9796 for (unsigned int iteration = 0; iteration < n_vertex && bool_operator2_result; ++iteration) 9797 { 9798 value = pVec4Operator2(pVec4Operator1(value)); 9799 } 9800 9801 break; 9802 } 9803 9804 case 1: 9805 { 9806 for (unsigned int iteration = 0; iteration < n_vertex * 2; ++iteration) 9807 { 9808 value = pVec4Operator1(pVec4Operator2(value)); 9809 } 9810 9811 break; 9812 } 9813 } /* switch (n_vertex % 2) */ 9814 9815 expected_value = value.x() + value.y() + value.z() + value.w(); 9816 } 9817 9818 if (de::abs(expected_value - *traveller_ptr) > epsilon) 9819 { 9820 m_testCtx.getLog() << tcu::TestLog::Message << "XFBed data was found to be invalid at index [" << n_vertex 9821 << "]" 9822 "for the following subroutine location configuration:" 9823 " bool_operator1_subroutine_location:[" 9824 << bool_operator1_subroutine_location << "]" 9825 " bool_operator2_subroutine_location:[" 9826 << bool_operator2_subroutine_location << "]" 9827 " vec4_operator1_subroutine_location:[" 9828 << vec4_operator1_subroutine_location << "]" 9829 " vec4_operator2_subroutine_location:[" 9830 << vec4_operator2_subroutine_location << "];" 9831 " expected data:" 9832 << expected_value << ", found:" << *traveller_ptr << tcu::TestLog::EndMessage; 9833 9834 m_has_test_passed = false; 9835 } 9836 9837 ++traveller_ptr; 9838 } /* for (all drawn points) */ 9839 } 9840 9841 /** Constructor. 9842 * 9843 * @param context Rendering context. 9844 * 9845 **/ 9846 NegativeTest1::NegativeTest1(deqp::Context& context) 9847 : TestCase(context, "subroutine_errors", "Verifies all GL_INVALID_OPERATION, GL_INVALID_VALUE, GL_INVALID ENUM " 9848 "errors related to subroutine usage are properly generated.") 9849 , m_has_test_passed(true) 9850 , m_po_active_subroutine_uniform_locations(0) 9851 , m_po_active_subroutine_uniforms(0) 9852 , m_po_active_subroutines(0) 9853 , m_po_subroutine_uniform_function_index(-1) 9854 , m_po_subroutine_uniform_function2_index(-1) 9855 , m_po_subroutine_test1_index(GL_INVALID_INDEX) 9856 , m_po_subroutine_test2_index(GL_INVALID_INDEX) 9857 , m_po_subroutine_test3_index(GL_INVALID_INDEX) 9858 , m_po_not_linked_id(0) 9859 , m_po_id(0) 9860 , m_vs_id(0) 9861 { 9862 /* Left blank intentionally */ 9863 } 9864 9865 /** Deinitializes all GL objects that may have been created during 9866 * test execution. 9867 **/ 9868 void NegativeTest1::deinit() 9869 { 9870 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9871 9872 if (m_po_id != 0) 9873 { 9874 gl.deleteProgram(m_po_id); 9875 9876 m_po_id = 0; 9877 } 9878 9879 if (m_po_not_linked_id != 0) 9880 { 9881 gl.deleteProgram(m_po_not_linked_id); 9882 9883 m_po_not_linked_id = 0; 9884 } 9885 9886 if (m_vs_id != 0) 9887 { 9888 gl.deleteShader(m_vs_id); 9889 9890 m_vs_id = 0; 9891 } 9892 } 9893 9894 /** Initializes all GL objects required to run the test. */ 9895 void NegativeTest1::initTest() 9896 { 9897 glw::GLint compile_status = GL_FALSE; 9898 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9899 9900 /* Create program objects */ 9901 m_po_not_linked_id = gl.createProgram(); 9902 m_po_id = gl.createProgram(); 9903 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call(s) failed."); 9904 9905 /* Create vertex shader object */ 9906 m_vs_id = gl.createShader(GL_VERTEX_SHADER); 9907 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 9908 9909 /* Set up vertex shader */ 9910 const char* vs_body = "#version 400\n" 9911 "\n" 9912 "#extension GL_ARB_shader_subroutine : require\n" 9913 "\n" 9914 "subroutine void subroutineType (out ivec2 arg);\n" 9915 "subroutine void subroutineType2(out ivec4 arg);\n" 9916 "\n" 9917 "subroutine(subroutineType) void test1(out ivec2 arg)\n" 9918 "{\n" 9919 " arg = ivec2(1, 2);\n" 9920 "}\n" 9921 "subroutine(subroutineType) void test2(out ivec2 arg)\n" 9922 "{\n" 9923 " arg = ivec2(3,4);\n" 9924 "}\n" 9925 "subroutine(subroutineType2) void test3(out ivec4 arg)\n" 9926 "{\n" 9927 " arg = ivec4(1, 2, 3, 4);\n" 9928 "}\n" 9929 "\n" 9930 "subroutine uniform subroutineType function;\n" 9931 "subroutine uniform subroutineType2 function2;\n" 9932 "\n" 9933 "void main()\n" 9934 "{\n" 9935 " ivec2 test;\n" 9936 " ivec4 test2;\n" 9937 "\n" 9938 " function(test);\n" 9939 "\n" 9940 " if (test.x > 2)\n" 9941 " {\n" 9942 " gl_Position = vec4(1);\n" 9943 " }\n" 9944 " else\n" 9945 " {\n" 9946 " function2(test2);\n" 9947 "\n" 9948 " gl_Position = vec4(float(test2.x) );\n" 9949 " }\n" 9950 "}\n"; 9951 9952 gl.shaderSource(m_vs_id, 1 /* count */, &vs_body, DE_NULL /* length */); 9953 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed"); 9954 9955 gl.compileShader(m_vs_id); 9956 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed"); 9957 9958 gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status); 9959 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed"); 9960 9961 if (compile_status == GL_FALSE) 9962 { 9963 TCU_FAIL("Shader compilation failed"); 9964 } 9965 9966 /* Set up & link the test program object */ 9967 glw::GLint link_status = GL_FALSE; 9968 9969 gl.attachShader(m_po_id, m_vs_id); 9970 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); 9971 9972 gl.linkProgram(m_po_id); 9973 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); 9974 9975 gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status); 9976 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 9977 9978 if (link_status == GL_FALSE) 9979 { 9980 TCU_FAIL("Program linking failed"); 9981 } 9982 9983 /* Query test program object's properties */ 9984 gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, 9985 &m_po_active_subroutine_uniform_locations); 9986 gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &m_po_active_subroutine_uniforms); 9987 gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &m_po_active_subroutines); 9988 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramStageiv() call(s) failed."); 9989 9990 if (m_po_active_subroutine_uniform_locations != 2) 9991 { 9992 TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS value returned"); 9993 } 9994 9995 m_po_subroutine_test1_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test1"); 9996 m_po_subroutine_test2_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test2"); 9997 m_po_subroutine_test3_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test3"); 9998 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); 9999 10000 if (m_po_subroutine_test1_index == GL_INVALID_INDEX || m_po_subroutine_test2_index == GL_INVALID_INDEX || 10001 m_po_subroutine_test3_index == GL_INVALID_INDEX) 10002 { 10003 TCU_FAIL("Invalid subroutine index returned"); 10004 } 10005 10006 m_po_subroutine_uniform_function_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "function"); 10007 m_po_subroutine_uniform_function2_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "function2"); 10008 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed."); 10009 10010 if (m_po_subroutine_uniform_function_index == -1 || m_po_subroutine_uniform_function2_index == -1) 10011 { 10012 TCU_FAIL("Invalid subroutine uniform index returned"); 10013 } 10014 } 10015 10016 /** Executes test iteration. 10017 * 10018 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 10019 */ 10020 tcu::TestNode::IterateResult NegativeTest1::iterate() 10021 { 10022 glw::GLenum error_code = GL_NO_ERROR; 10023 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10024 10025 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 10026 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 10027 { 10028 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 10029 } 10030 10031 /* Initialize GL objects required to run the test */ 10032 initTest(); 10033 10034 /* The error INVALID_OPERATION is generated by GetSubroutineUniformLocation 10035 * if the program object identified by <program> has not been successfully 10036 * linked. 10037 */ 10038 gl.getSubroutineUniformLocation(m_po_not_linked_id, GL_FRAGMENT_SHADER, "subroutine_uniform_name"); 10039 10040 error_code = gl.getError(); 10041 10042 if (error_code != GL_INVALID_OPERATION) 10043 { 10044 m_testCtx.getLog() << tcu::TestLog::Message 10045 << "glGetSubroutineUniformLocation() does not generate GL_INVALID_OPERATION " 10046 "error code when called for a non-linked program object." 10047 << tcu::TestLog::EndMessage; 10048 10049 m_has_test_passed = false; 10050 } 10051 10052 /* The error INVALID_VALUE is generated by GetActiveSubroutineUniformiv or 10053 * GetActiveSubroutineUniformName if <index> is greater than or equal to the 10054 * value of ACTIVE_SUBROUTINE_UNIFORMS for the shader stage. 10055 */ 10056 glw::GLint temp_length = 0; 10057 glw::GLint temp_values = 0; 10058 10059 gl.getActiveSubroutineUniformiv(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms, 10060 GL_NUM_COMPATIBLE_SUBROUTINES, &temp_values); 10061 error_code = gl.getError(); 10062 10063 if (error_code == GL_INVALID_VALUE) 10064 { 10065 gl.getActiveSubroutineUniformiv(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms + 1, 10066 GL_NUM_COMPATIBLE_SUBROUTINES, &temp_values); 10067 10068 error_code = gl.getError(); 10069 } 10070 10071 if (error_code != GL_INVALID_VALUE) 10072 { 10073 m_testCtx.getLog() << tcu::TestLog::Message 10074 << "glGetActiveSubroutineUniformiv() does not generate GL_INVALID_VALUE " 10075 "when passed <index> argument that is greater than or equal to " 10076 "the value of GL_ACTIVE_SUBROUTINE_UNIFORMS." 10077 << tcu::TestLog::EndMessage; 10078 10079 m_has_test_passed = false; 10080 } 10081 10082 gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms, 0, /* bufsize */ 10083 &temp_length, DE_NULL); /* name */ 10084 error_code = gl.getError(); 10085 10086 if (error_code == GL_INVALID_VALUE) 10087 { 10088 gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms + 1, 10089 0, /* bufsize */ 10090 &temp_length, DE_NULL); /* name */ 10091 10092 error_code = gl.getError(); 10093 } 10094 10095 if (error_code != GL_INVALID_VALUE) 10096 { 10097 m_testCtx.getLog() << tcu::TestLog::Message 10098 << "glGetActiveSubroutineUniformName() does not generate GL_INVALID_VALUE " 10099 "when passed <index> argument that is greater than or equal to " 10100 "the value of GL_ACTIVE_SUBROUTINE_UNIFORMS." 10101 << tcu::TestLog::EndMessage; 10102 10103 m_has_test_passed = false; 10104 } 10105 10106 /* The error INVALID_VALUE is generated by GetActiveSubroutineName if <index> 10107 * is greater than or equal to the value of ACTIVE_SUBROUTINES for the shader 10108 * stage. 10109 */ 10110 gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutines, 0, /* bufsize */ 10111 &temp_length, DE_NULL); /* name */ 10112 error_code = gl.getError(); 10113 10114 if (error_code == GL_INVALID_VALUE) 10115 { 10116 gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutines + 1, 0, /* bufsize */ 10117 &temp_length, DE_NULL); /* name */ 10118 10119 error_code = gl.getError(); 10120 } 10121 10122 if (error_code != GL_INVALID_VALUE) 10123 { 10124 m_testCtx.getLog() << tcu::TestLog::Message << "glGetActiveSubroutineName() does not generate GL_INVALID_VALUE " 10125 "when passed <index> argument that is greater than or equal to " 10126 "the value of GL_ACTIVE_SUBROUTINES." 10127 << tcu::TestLog::EndMessage; 10128 10129 m_has_test_passed = false; 10130 } 10131 10132 /* The error INVALID_VALUE is generated by UniformSubroutinesuiv if <count> 10133 * is not equal to the value of ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the 10134 * shader stage <shadertype>. 10135 */ 10136 glw::GLuint index = 0; 10137 10138 gl.useProgram(m_po_id); 10139 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 10140 10141 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations - 1, &index); 10142 error_code = gl.getError(); 10143 10144 if (error_code == GL_INVALID_VALUE) 10145 { 10146 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations + 1, &index); 10147 10148 error_code = gl.getError(); 10149 } 10150 10151 if (error_code != GL_INVALID_VALUE) 10152 { 10153 m_testCtx.getLog() << tcu::TestLog::Message << "glUniformSubroutinesiv() does not generate GL_INVALID_VALUE " 10154 "when passed <count> argument that is not equal to the value of " 10155 "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS." 10156 << tcu::TestLog::EndMessage; 10157 10158 m_has_test_passed = false; 10159 } 10160 10161 /* The error INVALID_VALUE is generated by UniformSubroutinesuiv if any value 10162 * in <indices> is greater than or equal to the value of ACTIVE_SUBROUTINES 10163 * for the shader stage. 10164 */ 10165 glw::GLuint invalid_subroutine_indices[4] = { (GLuint)m_po_active_subroutines, (GLuint)m_po_active_subroutines, 10166 (GLuint)m_po_active_subroutines + 1, 10167 (GLuint)m_po_active_subroutines + 1 }; 10168 10169 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, /* count */ 10170 invalid_subroutine_indices + 0); 10171 error_code = gl.getError(); 10172 10173 if (error_code == GL_INVALID_VALUE) 10174 { 10175 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, 10176 invalid_subroutine_indices + 2); 10177 10178 error_code = gl.getError(); 10179 } 10180 10181 if (error_code != GL_INVALID_VALUE) 10182 { 10183 m_testCtx.getLog() << tcu::TestLog::Message << "glUniformSubroutinesuiv() does not generate GL_INVALID_VALUE " 10184 "when the value passed via <indices> argument is greater than " 10185 "or equal to the value of GL_ACTIVE_SUBROUTINES." 10186 << tcu::TestLog::EndMessage; 10187 10188 m_has_test_passed = false; 10189 } 10190 10191 /* The error INVALID_OPERATION is generated by UniformSubroutinesuiv() if any 10192 * subroutine index in <indices> identifies a subroutine not associated with 10193 * the type of the subroutine uniform variable assigned to the corresponding 10194 * location. 10195 */ 10196 glw::GLuint invalid_subroutine_indices2[2] = { m_po_subroutine_test1_index, m_po_subroutine_test1_index }; 10197 10198 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, invalid_subroutine_indices2); 10199 error_code = gl.getError(); 10200 10201 if (error_code != GL_INVALID_OPERATION) 10202 { 10203 m_testCtx.getLog() << tcu::TestLog::Message 10204 << "glUniformSubroutinesuiv() does not generate GL_INVALID_OPERATION " 10205 "when the subroutine index passed via <indices> argument identifies" 10206 "a subroutine not associated with the type of the subroutine uniform " 10207 "assigned to the corresponding location." 10208 << tcu::TestLog::EndMessage; 10209 10210 m_has_test_passed = false; 10211 } 10212 10213 /* The error INVALID_OPERATION is generated by UniformSubroutinesuiv if no 10214 * program is active. 10215 */ 10216 glw::GLuint valid_subroutine_locations[2] = { 0 }; 10217 10218 valid_subroutine_locations[m_po_subroutine_uniform_function_index] = m_po_subroutine_test1_index; 10219 valid_subroutine_locations[m_po_subroutine_uniform_function2_index] = m_po_subroutine_test3_index; 10220 10221 gl.useProgram(0); 10222 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 10223 10224 gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, valid_subroutine_locations); 10225 error_code = gl.getError(); 10226 10227 if (error_code != GL_INVALID_OPERATION) 10228 { 10229 m_testCtx.getLog() << tcu::TestLog::Message 10230 << "glUniformSubroutinesuiv() does not generate GL_INVALID_OPERATION " 10231 "when called without an active program object." 10232 << tcu::TestLog::EndMessage; 10233 10234 m_has_test_passed = false; 10235 } 10236 10237 /* The error INVALID_VALUE is generated by GetUniformSubroutineuiv if 10238 * <location> is greater than or equal to the value of 10239 * ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the shader stage. 10240 */ 10241 glw::GLuint temp_value = 0; 10242 10243 gl.useProgram(m_po_id); 10244 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); 10245 10246 gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, &temp_value); 10247 error_code = gl.getError(); 10248 10249 if (error_code == GL_INVALID_VALUE) 10250 { 10251 gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations + 1, &temp_value); 10252 error_code = gl.getError(); 10253 } 10254 10255 if (error_code != GL_INVALID_VALUE) 10256 { 10257 m_testCtx.getLog() << tcu::TestLog::Message 10258 << "glGetUniformSubroutineuiv() does not generate GL_INVALID_VALUE " 10259 "when called for location that is greater than or equal to the value " 10260 "of GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS." 10261 << tcu::TestLog::EndMessage; 10262 10263 m_has_test_passed = false; 10264 } 10265 10266 /* The error INVALID_OPERATION is generated by GetUniformSubroutineuiv if no 10267 * program is active for the shader stage identified by <shadertype>. 10268 */ 10269 const glw::GLenum undefined_shader_stages[] = { GL_FRAGMENT_SHADER, GL_GEOMETRY_SHADER, GL_TESS_CONTROL_SHADER, 10270 GL_TESS_EVALUATION_SHADER }; 10271 const unsigned int n_undefined_shader_stages = sizeof(undefined_shader_stages) / sizeof(undefined_shader_stages[0]); 10272 10273 for (unsigned int n_undefined_shader_stage = 0; n_undefined_shader_stage < n_undefined_shader_stages; 10274 ++n_undefined_shader_stage) 10275 { 10276 glw::GLenum shader_stage = undefined_shader_stages[n_undefined_shader_stage]; 10277 10278 gl.getUniformSubroutineuiv(shader_stage, 0, /* location */ 10279 &temp_value); 10280 error_code = gl.getError(); 10281 10282 if (error_code != GL_INVALID_OPERATION) 10283 { 10284 m_testCtx.getLog() << tcu::TestLog::Message 10285 << "glGetUniformSubroutineuiv() does not generate GL_INVALID_OPERATION " 10286 "when called for a shader stage that is not defined for active " 10287 "program object." 10288 << tcu::TestLog::EndMessage; 10289 10290 m_has_test_passed = false; 10291 } 10292 } /* for (all undefined shader stages) */ 10293 10294 /* All done */ 10295 if (m_has_test_passed) 10296 { 10297 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 10298 } 10299 else 10300 { 10301 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 10302 } 10303 10304 return STOP; 10305 } 10306 10307 /** Constructor 10308 * 10309 * @param context Rendering context. 10310 * 10311 **/ 10312 NegativeTest2::NegativeTest2(deqp::Context& context) 10313 : TestCase(context, "subroutine_uniform_scope", "Verifies subroutine uniforms declared in shader stage A" 10314 "cannot be accessed from a different stage.") 10315 , m_fs_id(0) 10316 , m_gs_id(0) 10317 , m_has_test_passed(true) 10318 , m_po_id(0) 10319 , m_tc_id(0) 10320 , m_te_id(0) 10321 , m_vs_id(0) 10322 { 10323 /* Left blank intentionally */ 10324 } 10325 10326 /** Deinitializes all GL objects that may have been created during test execution */ 10327 void NegativeTest2::deinit() 10328 { 10329 deinitGLObjects(); 10330 } 10331 10332 /** Deinitializes all GL objects that may have been created during test execution */ 10333 void NegativeTest2::deinitGLObjects() 10334 { 10335 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10336 10337 if (m_fs_id != 0) 10338 { 10339 gl.deleteShader(m_fs_id); 10340 10341 m_fs_id = 0; 10342 } 10343 10344 if (m_gs_id != 0) 10345 { 10346 gl.deleteShader(m_gs_id); 10347 10348 m_gs_id = 0; 10349 } 10350 10351 if (m_tc_id != 0) 10352 { 10353 gl.deleteShader(m_tc_id); 10354 10355 m_tc_id = 0; 10356 } 10357 10358 if (m_te_id != 0) 10359 { 10360 gl.deleteShader(m_te_id); 10361 10362 m_te_id = 0; 10363 } 10364 10365 if (m_vs_id != 0) 10366 { 10367 gl.deleteShader(m_vs_id); 10368 10369 m_vs_id = 0; 10370 } 10371 10372 if (m_po_id != 0) 10373 { 10374 gl.deleteProgram(m_po_id); 10375 10376 m_po_id = 0; 10377 } 10378 } 10379 10380 /** Builds an offending program object and tries to link it. We're either expecting 10381 * a compile-time or link-time error here. 10382 * 10383 * If the program object builds successfully, the test has failed. 10384 * 10385 * @param referencing_stage Shader stage which defines a subroutine uniform that 10386 * should be called from fragment/geometry/tess control/ 10387 * tess evaluation/vertex shader stages. 10388 * 10389 **/ 10390 void NegativeTest2::executeTestCase(const Utils::_shader_stage& referencing_stage) 10391 { 10392 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10393 10394 const std::string fs_body = getFragmentShaderBody(referencing_stage); 10395 const std::string gs_body = getGeometryShaderBody(referencing_stage); 10396 const std::string tc_body = getTessellationControlShaderBody(referencing_stage); 10397 const std::string te_body = getTessellationEvaluationShaderBody(referencing_stage); 10398 const std::string vs_body = getVertexShaderBody(referencing_stage); 10399 10400 if (Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, NULL, /* xfb_varyings */ 10401 0, /* n_xfb_varyings */ 10402 &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) 10403 { 10404 /* Test program should not have built correctly ! */ 10405 m_testCtx.getLog() << tcu::TestLog::Message << "In the following program, one of the stages references " 10406 "a subroutine that is defined in another stage. This " 10407 "is forbidden by the specification.\n" 10408 "\n" 10409 "Vertex shader:\n\n" 10410 << vs_body.c_str() << "\n\nTessellation control shader:\n\n" 10411 << tc_body.c_str() << "\n\nTessellation evaluation shader:\n\n" 10412 << te_body.c_str() << "\n\nGeometry shader:\n\n" 10413 << gs_body.c_str() << "\n\nFragment shader:\n\n" 10414 << fs_body.c_str() << tcu::TestLog::EndMessage; 10415 10416 m_has_test_passed = false; 10417 } /* if (test program was built successfully) */ 10418 10419 /* Release the shaders & the program object that buildProgram() created */ 10420 deinitGLObjects(); 10421 } 10422 10423 /** Retrieves an offending fragment shader body. 10424 * 10425 * @param referencing_stage Shader stage which defines the subroutine uniform that 10426 * will be called from fragment shader. 10427 * 10428 * @return Requested string. 10429 **/ 10430 std::string NegativeTest2::getFragmentShaderBody(const Utils::_shader_stage& referencing_stage) const 10431 { 10432 std::stringstream result; 10433 10434 /* Form the pre-amble */ 10435 result << "#version 400\n" 10436 "\n" 10437 "#extension GL_ARB_shader_subroutine : require\n" 10438 "\n" 10439 "subroutine void testSubroutineType(out vec4 test_argument);\n" 10440 "\n" 10441 /* Define a subroutine */ 10442 "subroutine(testSubroutineType) void fs_subroutine(out vec4 test_argument)\n" 10443 "{\n" 10444 " test_argument = vec4(1, 0, 0, 0);\n" 10445 "}\n" 10446 "\n" 10447 /* Define output variables */ 10448 "out vec4 result;\n" 10449 "\n" 10450 /* Define uniforms */ 10451 "subroutine uniform testSubroutineType test_fs_subroutine;\n" 10452 "\n" 10453 /* Define main() */ 10454 "void main()\n" 10455 "{\n" 10456 " " 10457 << getSubroutineUniformName(referencing_stage) << "(result);\n" 10458 "}\n"; 10459 10460 return result.str(); 10461 } 10462 10463 /** Retrieves an offending geometry shader body. 10464 * 10465 * @param referencing_stage Shader stage which defines the subroutine uniform that 10466 * will be called from geometry shader. 10467 * 10468 * @return Requested string. 10469 **/ 10470 std::string NegativeTest2::getGeometryShaderBody(const Utils::_shader_stage& referencing_stage) const 10471 { 10472 std::stringstream result; 10473 10474 /* Form the pre-amble */ 10475 result << "#version 400\n" 10476 "\n" 10477 "#extension GL_ARB_shader_subroutine : require\n" 10478 "\n" 10479 "subroutine void testSubroutineType(out vec4 test_argument);\n" 10480 "\n" 10481 "layout(points) in;\n" 10482 "layout(points, max_vertices = 1) out;\n" 10483 "\n" 10484 /* Define a subroutine */ 10485 "subroutine(testSubroutineType) void gs_subroutine(out vec4 test_argument)\n" 10486 "{\n" 10487 " test_argument = vec4(0, 1, 1, 1);\n" 10488 "}\n" 10489 "\n" 10490 /* Define output variables */ 10491 "out vec4 result;\n" 10492 "\n" 10493 /* Define uniforms */ 10494 "subroutine uniform testSubroutineType test_gs_subroutine;\n" 10495 "\n" 10496 /* Define main() */ 10497 "void main()\n" 10498 "{\n" 10499 " " 10500 << getSubroutineUniformName(referencing_stage) << "(result);\n" 10501 "}\n"; 10502 10503 return result.str(); 10504 } 10505 10506 /** Retrieves name of the subroutine uniform that is defined in user-specified 10507 * shader stage. 10508 * 10509 * @param stage Shader stage to retrieve the subroutine uniform name for. 10510 * 10511 * @return As per description. 10512 **/ 10513 std::string NegativeTest2::getSubroutineUniformName(const Utils::_shader_stage& stage) const 10514 { 10515 std::string result = "?"; 10516 10517 switch (stage) 10518 { 10519 case Utils::SHADER_STAGE_FRAGMENT: 10520 { 10521 result = "test_fs_subroutine"; 10522 10523 break; 10524 } 10525 10526 case Utils::SHADER_STAGE_GEOMETRY: 10527 { 10528 result = "test_gs_subroutine"; 10529 10530 break; 10531 } 10532 10533 case Utils::SHADER_STAGE_TESSELLATION_CONTROL: 10534 { 10535 result = "test_tc_subroutine"; 10536 10537 break; 10538 } 10539 10540 case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: 10541 { 10542 result = "test_te_subroutine"; 10543 10544 break; 10545 } 10546 10547 case Utils::SHADER_STAGE_VERTEX: 10548 { 10549 result = "test_vs_subroutine"; 10550 10551 break; 10552 } 10553 10554 default: 10555 { 10556 TCU_FAIL("Unrecognized shader stage requested"); 10557 } 10558 } /* switch (stage) */ 10559 10560 return result; 10561 } 10562 10563 /** Retrieves an offending tessellation control shader body. 10564 * 10565 * @param referencing_stage Shader stage which defines the subroutine uniform that 10566 * will be called from tessellation control shader. 10567 * 10568 * @return Requested string. 10569 **/ 10570 std::string NegativeTest2::getTessellationControlShaderBody(const Utils::_shader_stage& referencing_stage) const 10571 { 10572 std::stringstream result; 10573 10574 /* Form the pre-amble */ 10575 result << "#version 400\n" 10576 "\n" 10577 "#extension GL_ARB_shader_subroutine : require\n" 10578 "\n" 10579 "layout(vertices = 4) out;\n" 10580 "\n" 10581 "subroutine void testSubroutineType(out vec4 test_argument);\n" 10582 "\n" 10583 /* Define a subroutine */ 10584 "subroutine(testSubroutineType) void tc_subroutine(out vec4 test_argument)\n" 10585 "{\n" 10586 " test_argument = vec4(0, 0, 1, 0);\n" 10587 "}\n" 10588 "\n" 10589 /* Define uniforms */ 10590 "subroutine uniform testSubroutineType test_tc_subroutine;\n" 10591 "\n" 10592 /* Define main() */ 10593 "void main()\n" 10594 "{\n" 10595 " " 10596 << getSubroutineUniformName(referencing_stage) << "(gl_out[gl_InvocationID].gl_Position);\n" 10597 "}\n"; 10598 10599 return result.str(); 10600 } 10601 10602 /** Retrieves an offending tessellation evaluation shader body. 10603 * 10604 * @param referencing_stage Shader stage which defines the subroutine uniform that 10605 * will be called from tessellation evaluation shader. 10606 * 10607 * @return Requested string. 10608 **/ 10609 std::string NegativeTest2::getTessellationEvaluationShaderBody(const Utils::_shader_stage& referencing_stage) const 10610 { 10611 std::stringstream result; 10612 10613 /* Form the pre-amble */ 10614 result << "#version 400\n" 10615 "\n" 10616 "#extension GL_ARB_shader_subroutine : require\n" 10617 "\n" 10618 "layout(quads) in;\n" 10619 "\n" 10620 "subroutine void testSubroutineType(out vec4 test_argument);\n" 10621 "\n" 10622 /* Define a subroutine */ 10623 "subroutine(testSubroutineType) void te_subroutine(out vec4 test_argument)\n" 10624 "{\n" 10625 " test_argument = vec4(1, 1, 1, 1);\n" 10626 "}\n" 10627 "\n" 10628 /* Define uniforms */ 10629 "subroutine uniform testSubroutineType test_te_subroutine;\n" 10630 "\n" 10631 /* Define main() */ 10632 "void main()\n" 10633 "{\n" 10634 " " 10635 << getSubroutineUniformName(referencing_stage) << "(gl_Position);\n" 10636 "}\n"; 10637 10638 return result.str(); 10639 } 10640 10641 /** Retrieves an offending vertex shader body. 10642 * 10643 * @param referencing_stage Shader stage which defines the subroutine uniform that 10644 * will be called from vertex shader. 10645 * 10646 * @return Requested string. 10647 **/ 10648 std::string NegativeTest2::getVertexShaderBody(const Utils::_shader_stage& referencing_stage) const 10649 { 10650 std::stringstream result; 10651 10652 /* Form the pre-amble */ 10653 result << "#version 400\n" 10654 "\n" 10655 "#extension GL_ARB_shader_subroutine : require\n" 10656 "\n" 10657 "subroutine void testSubroutineType(out vec4 test_argument);\n" 10658 "\n" 10659 /* Define a subroutine */ 10660 "subroutine(testSubroutineType) void vs_subroutine(out vec4 test_argument)\n" 10661 "{\n" 10662 " test_argument = vec4(0, 1, 0, 0);\n" 10663 "}\n" 10664 "\n" 10665 /* Define uniforms */ 10666 "subroutine uniform testSubroutineType test_vs_subroutine;\n" 10667 "\n" 10668 /* Define main() */ 10669 "void main()\n" 10670 "{\n" 10671 " " 10672 << getSubroutineUniformName(referencing_stage) << "(gl_Position);\n" 10673 "}\n"; 10674 10675 return result.str(); 10676 } 10677 10678 /** Executes test iteration. 10679 * 10680 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 10681 */ 10682 tcu::TestNode::IterateResult NegativeTest2::iterate() 10683 { 10684 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 10685 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 10686 { 10687 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 10688 } 10689 10690 /* Iterate over all shader stages and execute the checks */ 10691 for (int referencing_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); 10692 referencing_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++referencing_stage) 10693 { 10694 executeTestCase(static_cast<Utils::_shader_stage>(referencing_stage)); 10695 } /* for (all test cases) */ 10696 10697 /* All done */ 10698 if (m_has_test_passed) 10699 { 10700 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 10701 } 10702 else 10703 { 10704 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 10705 } 10706 10707 return STOP; 10708 } 10709 10710 /** Constructor. 10711 * 10712 * @param context Rendering context. 10713 * 10714 **/ 10715 NegativeTest3::NegativeTest3(deqp::Context& context) 10716 : TestCase(context, "missing_subroutine_keyword", "Verifies that subroutine keyword is necessary when declaring a " 10717 "subroutine uniforn and a compilation error occurs without it.") 10718 , m_has_test_passed(true) 10719 , m_so_id(0) 10720 { 10721 /* Left blank intentionally */ 10722 } 10723 10724 /** Deinitializes all GL objects that may have been created during test execution */ 10725 void NegativeTest3::deinit() 10726 { 10727 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10728 10729 if (m_so_id != 0) 10730 { 10731 gl.deleteShader(m_so_id); 10732 10733 m_so_id = 0; 10734 } 10735 } 10736 10737 /** Verifies that broken shader (for user-specified shader stage) does not compile. 10738 * 10739 * @param shader_stage Shader stage to use for the test. 10740 **/ 10741 void NegativeTest3::executeTest(const Utils::_shader_stage& shader_stage) 10742 { 10743 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10744 10745 /* Generate a new shader object */ 10746 m_so_id = gl.createShader(Utils::getGLenumForShaderStage(shader_stage)); 10747 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); 10748 10749 /* Assign body to the shader */ 10750 std::string body; 10751 const char* body_raw_ptr = DE_NULL; 10752 10753 switch (shader_stage) 10754 { 10755 case Utils::SHADER_STAGE_VERTEX: 10756 body = getVertexShaderBody(); 10757 break; 10758 case Utils::SHADER_STAGE_TESSELLATION_CONTROL: 10759 body = getTessellationControlShaderBody(); 10760 break; 10761 case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: 10762 body = getTessellationEvaluationShaderBody(); 10763 break; 10764 case Utils::SHADER_STAGE_GEOMETRY: 10765 body = getGeometryShaderBody(); 10766 break; 10767 case Utils::SHADER_STAGE_FRAGMENT: 10768 body = getFragmentShaderBody(); 10769 break; 10770 10771 default: 10772 { 10773 TCU_FAIL("Unrecognized shader stage requested"); 10774 } 10775 } /* switch (shader_stage) */ 10776 10777 body_raw_ptr = body.c_str(); 10778 10779 gl.shaderSource(m_so_id, 1 /* count */, &body_raw_ptr, DE_NULL /* length */); 10780 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); 10781 10782 /* Try to compile the shader */ 10783 glw::GLint compile_status = 0; 10784 10785 gl.compileShader(m_so_id); 10786 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); 10787 10788 gl.getShaderiv(m_so_id, GL_COMPILE_STATUS, &compile_status); 10789 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 10790 10791 if (compile_status == GL_TRUE) 10792 { 10793 m_testCtx.getLog() << tcu::TestLog::Message << "The following shader was expected to fail to compile but was " 10794 "accepted by the compiler:\n" 10795 "\n" 10796 << body.c_str() << tcu::TestLog::EndMessage; 10797 10798 m_has_test_passed = false; 10799 } 10800 10801 /* Good to release the shader at this point */ 10802 gl.deleteShader(m_so_id); 10803 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed."); 10804 } 10805 10806 /** Retrieves body of a broken fragment shader. 10807 * 10808 * @return Requested string. 10809 **/ 10810 std::string NegativeTest3::getFragmentShaderBody() const 10811 { 10812 return "#version 400\n" 10813 "\n" 10814 "#extension GL_ARB_shader_subroutine : require\n" 10815 "\n" 10816 "subroutine void testSubroutineType(inout vec4 test);\n" 10817 "\n" 10818 "void testSubroutine1(inout vec4 test)\n" 10819 "{\n" 10820 " test += vec4(3, 4, 5, 6);\n" 10821 "}\n" 10822 "\n" 10823 "uniform testSubroutineType subroutineFunction;\n" 10824 "out vec4 result;\n" 10825 "\n" 10826 "void main()\n" 10827 "{\n" 10828 " vec4 test = vec4(2, 3, 4, 5);\n" 10829 "\n" 10830 " subroutineFunction(test);\n" 10831 "\n" 10832 " result = test;\n" 10833 "}\n"; 10834 } 10835 10836 /** Retrieves body of a broken geometry shader. 10837 * 10838 * @return Requested string. 10839 **/ 10840 std::string NegativeTest3::getGeometryShaderBody() const 10841 { 10842 return "#version 400\n" 10843 "\n" 10844 "#extension GL_ARB_shader_subroutine : require\n" 10845 "\n" 10846 "layout(points) in;\n" 10847 "layout(points, max_vertices = 1) out;\n" 10848 "\n" 10849 "subroutine void testSubroutineType(inout vec4 test);\n" 10850 "\n" 10851 "void testSubroutine1(inout vec4 test)\n" 10852 "{\n" 10853 " test += vec4(3, 4, 5, 6);\n" 10854 "}\n" 10855 "\n" 10856 "uniform testSubroutineType subroutineFunction;\n" 10857 "\n" 10858 "void main()\n" 10859 "{\n" 10860 " vec4 test = vec4(2, 3, 4, 5);\n" 10861 "\n" 10862 " subroutineFunction(test);\n" 10863 "\n" 10864 " gl_Position = test;\n" 10865 " EmitVertex();\n" 10866 "}\n"; 10867 } 10868 10869 /** Retrieves body of a broken tessellation control shader. 10870 * 10871 * @return Requested string. 10872 **/ 10873 std::string NegativeTest3::getTessellationControlShaderBody() const 10874 { 10875 return "#version 400\n" 10876 "\n" 10877 "#extension GL_ARB_shader_subroutine : require\n" 10878 "\n" 10879 "layout(vertices=4) out;\n" 10880 "\n" 10881 "subroutine void testSubroutineType(inout vec4 test);\n" 10882 "\n" 10883 "void testSubroutine1(inout vec4 test)\n" 10884 "{\n" 10885 " test += vec4(1, 2, 3, 4);\n" 10886 "}\n" 10887 "\n" 10888 "uniform testSubroutineType subroutineFunction;\n" 10889 "\n" 10890 "void main()\n" 10891 "{\n" 10892 " vec4 test = vec4(0, 1, 2, 3);\n" 10893 "\n" 10894 " subroutineFunction(test);\n" 10895 "\n" 10896 " gl_out[gl_InvocationID].gl_Position = test;\n" 10897 "}\n"; 10898 } 10899 10900 /** Retrieves body of a broken tessellation evaluation shader. 10901 * 10902 * @return Requested string. 10903 **/ 10904 std::string NegativeTest3::getTessellationEvaluationShaderBody() const 10905 { 10906 return "#version 400\n" 10907 "\n" 10908 "#extension GL_ARB_shader_subroutine : require\n" 10909 "\n" 10910 "layout(quads) in;\n" 10911 "\n" 10912 "subroutine void testSubroutineType(inout vec4 test);\n" 10913 "\n" 10914 "void testSubroutine1(inout vec4 test)\n" 10915 "{\n" 10916 " test += vec4(2, 3, 4, 5);\n" 10917 "}\n" 10918 "\n" 10919 "uniform testSubroutineType subroutineFunction;\n" 10920 "\n" 10921 "void main()\n" 10922 "{\n" 10923 " vec4 test = vec4(1, 2, 3, 4);\n" 10924 "\n" 10925 " subroutineFunction(test);\n" 10926 "\n" 10927 " gl_Position = test;\n" 10928 "}\n"; 10929 } 10930 10931 /** Retrieves body of a broken vertex shader. 10932 * 10933 * @return Requested string. 10934 **/ 10935 std::string NegativeTest3::getVertexShaderBody() const 10936 { 10937 return "#version 400\n" 10938 "\n" 10939 "#extension GL_ARB_shader_subroutine : require\n" 10940 "\n" 10941 "subroutine void testSubroutineType(inout vec4 test);\n" 10942 "\n" 10943 "void testSubroutine1(inout vec4 test)\n" 10944 "{\n" 10945 " test += vec4(0, 1, 2, 3);\n" 10946 "}\n" 10947 "\n" 10948 "uniform testSubroutineType subroutineFunction;\n" 10949 "\n" 10950 "void main()\n" 10951 "{\n" 10952 " subroutineFunction(gl_Position);\n" 10953 "}\n"; 10954 } 10955 10956 /** Executes test iteration. 10957 * 10958 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 10959 */ 10960 tcu::TestNode::IterateResult NegativeTest3::iterate() 10961 { 10962 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 10963 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 10964 { 10965 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 10966 } 10967 10968 /* Iterate over all shader stages */ 10969 for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); 10970 shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) 10971 { 10972 executeTest(static_cast<Utils::_shader_stage>(shader_stage)); 10973 } /* for (all shader stages) */ 10974 10975 /* Done */ 10976 if (m_has_test_passed) 10977 { 10978 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 10979 } 10980 else 10981 { 10982 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 10983 } 10984 10985 return STOP; 10986 } 10987 10988 /** Constructor. 10989 * 10990 * @param context Rendering context. 10991 * 10992 **/ 10993 NegativeTest4::NegativeTest4(deqp::Context& context) 10994 : TestCase(context, "subroutines_incompatible_with_subroutine_type", 10995 "Verifies that a compile-time error is generated when arguments and " 10996 "return type do not match beween the function and each associated " 10997 "subroutine type.") 10998 , m_has_test_passed(true) 10999 , m_so_id(0) 11000 { 11001 /* Left blank intentionally */ 11002 } 11003 11004 /** Deinitializes GL objects that may have been created during test 11005 * execution. 11006 **/ 11007 void NegativeTest4::deinit() 11008 { 11009 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 11010 11011 if (m_so_id != 0) 11012 { 11013 gl.deleteShader(m_so_id); 11014 11015 m_so_id = 0; 11016 } 11017 } 11018 11019 /** Retrieves body of a shader of user-specified type that should be used 11020 * for a single test iteration. The shader will define user-specified number 11021 * of subroutine types, with the last type either defining an additional argument 11022 * or using a different return type. 11023 * A subroutine (claimed compatible with *all* subroutine types) will also be 11024 * defined in the shader. 11025 * 11026 * @param shader_stage Shader stage to use for the query. 11027 * @param n_subroutine_types Overall number of subroutine types that will be 11028 * declared & used in the shader. Please see description 11029 * for more details. 11030 * 11031 * @return Requested string. 11032 **/ 11033 std::string NegativeTest4::getShaderBody(const Utils::_shader_stage& shader_stage, 11034 const unsigned int& n_subroutine_types, const _test_case& test_case) const 11035 { 11036 std::stringstream result_sstream; 11037 11038 /* Form the pre-amble */ 11039 result_sstream << "#version 400\n" 11040 "\n" 11041 "#extension GL_ARB_shader_subroutine : require\n" 11042 "\n"; 11043 11044 /* Inject stage-specific code */ 11045 switch (shader_stage) 11046 { 11047 case Utils::SHADER_STAGE_GEOMETRY: 11048 { 11049 result_sstream << "layout (points) in;\n" 11050 "layout (points, max_vertices = 1) out;\n" 11051 "\n"; 11052 11053 break; 11054 } 11055 11056 case Utils::SHADER_STAGE_TESSELLATION_CONTROL: 11057 { 11058 result_sstream << "layout (vertices = 4) out;\n" 11059 "\n"; 11060 11061 break; 11062 } 11063 11064 case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: 11065 { 11066 result_sstream << "layout (quads) in;\n" 11067 "\n"; 11068 11069 break; 11070 } 11071 11072 default: 11073 break; 11074 } /* switch (shader_stage) */ 11075 11076 /* Insert subroutine type declarations */ 11077 for (unsigned int n_subroutine_type = 0; n_subroutine_type < n_subroutine_types - 1; ++n_subroutine_type) 11078 { 11079 result_sstream << "subroutine void subroutineType" << n_subroutine_type << "(inout vec3 argument);\n"; 11080 } /* for (all subroutine types) */ 11081 11082 switch (test_case) 11083 { 11084 case TEST_CASE_INCOMPATIBLE_ARGUMENT_LIST: 11085 { 11086 result_sstream << "subroutine void subroutineType" << (n_subroutine_types - 1) 11087 << "(inout vec3 argument, out vec4 argument2);\n"; 11088 11089 break; 11090 } 11091 11092 case TEST_CASE_INCOMPATIBLE_RETURN_TYPE: 11093 { 11094 result_sstream << "subroutine int subroutineType" << (n_subroutine_types - 1) << "(inout vec3 argument);\n"; 11095 11096 break; 11097 } 11098 11099 default: 11100 { 11101 TCU_FAIL("Unrecognized test case"); 11102 } 11103 } /* switch (test_case) */ 11104 11105 /* Insert subroutine declarations */ 11106 result_sstream << "subroutine("; 11107 11108 for (unsigned int n_subroutine_type = 0; n_subroutine_type < n_subroutine_types; ++n_subroutine_type) 11109 { 11110 result_sstream << "subroutineType" << n_subroutine_type; 11111 11112 if (n_subroutine_type != (n_subroutine_types - 1)) 11113 { 11114 result_sstream << ", "; 11115 } 11116 } /* for (all subroutine types) */ 11117 11118 result_sstream << ") void function(inout vec3 argument)\n" 11119 "{\n" 11120 " argument = vec3(1, 2, 3);\n" 11121 "}\n" 11122 "\n"; 11123 11124 /* Insert remaining required stage-specific bits */ 11125 switch (shader_stage) 11126 { 11127 case Utils::SHADER_STAGE_FRAGMENT: 11128 { 11129 result_sstream << "out vec4 result;\n" 11130 "\n" 11131 "void main()\n" 11132 "{\n" 11133 " result = vec4(1, 2, 3, 4);\n" 11134 "}\n"; 11135 11136 break; 11137 } 11138 11139 case Utils::SHADER_STAGE_GEOMETRY: 11140 { 11141 result_sstream << "void main()\n" 11142 "{\n" 11143 " gl_Position = vec4(1, 2, 3, 4);\n" 11144 " EmitVertex();\n" 11145 "}\n"; 11146 11147 break; 11148 } 11149 11150 case Utils::SHADER_STAGE_TESSELLATION_CONTROL: 11151 { 11152 result_sstream << "void main()\n" 11153 "{\n" 11154 " gl_TessLevelInner[0] = 1;\n" 11155 " gl_TessLevelInner[1] = 1;\n" 11156 " gl_TessLevelOuter[0] = 1;\n" 11157 " gl_TessLevelOuter[1] = 1;\n" 11158 " gl_TessLevelOuter[2] = 1;\n" 11159 " gl_TessLevelOuter[3] = 1;\n" 11160 " gl_out[gl_InvocationID].gl_Position = vec4(2, 3, 4, 5);\n" 11161 "}\n"; 11162 11163 break; 11164 } 11165 11166 case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: 11167 case Utils::SHADER_STAGE_VERTEX: 11168 { 11169 result_sstream << "void main()\n" 11170 "{\n" 11171 " gl_Position = vec4(1, 2, 3, 4);\n" 11172 "}\n"; 11173 11174 break; 11175 } 11176 11177 default: 11178 { 11179 TCU_FAIL("Unrecognized shader stage"); 11180 } 11181 } /* switch (shader_stage) */ 11182 11183 return result_sstream.str(); 11184 } 11185 11186 /** Executes test iteration. 11187 * 11188 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 11189 */ 11190 tcu::TestNode::IterateResult NegativeTest4::iterate() 11191 { 11192 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 11193 11194 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 11195 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 11196 { 11197 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 11198 } 11199 11200 /* Iterate over all shader stages.. */ 11201 for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); 11202 shader_stage != static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) 11203 { 11204 /* For each shader stage, we will be trying to compile a number of invalid shaders. 11205 * Each shader defines N different subroutine types. (N-1) of them are compatible 11206 * with a subroutine, but exactly 1 will be mismatched. The test passes if GLSL 11207 * compiler correctly detects that all shaders we will be trying to compile are 11208 * broken. 11209 */ 11210 const glw::GLenum shader_type = Utils::getGLenumForShaderStage(static_cast<Utils::_shader_stage>(shader_stage)); 11211 11212 for (unsigned int n_subroutine_types = 1; n_subroutine_types < 6; /* arbitrary number */ 11213 ++n_subroutine_types) 11214 { 11215 for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); 11216 ++test_case) 11217 { 11218 std::string body; 11219 const char* body_raw_ptr = NULL; 11220 glw::GLint compile_status = GL_FALSE; 11221 11222 body = getShaderBody(static_cast<Utils::_shader_stage>(shader_stage), n_subroutine_types, 11223 static_cast<_test_case>(test_case)); 11224 body_raw_ptr = body.c_str(); 11225 11226 /* Try to compile the shader */ 11227 m_so_id = gl.createShader(shader_type); 11228 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed"); 11229 11230 gl.shaderSource(m_so_id, 1 /* count */, &body_raw_ptr, DE_NULL); 11231 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed"); 11232 11233 gl.compileShader(m_so_id); 11234 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed"); 11235 11236 gl.getShaderiv(m_so_id, GL_COMPILE_STATUS, &compile_status); 11237 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 11238 11239 if (compile_status == GL_TRUE) 11240 { 11241 m_testCtx.getLog() << tcu::TestLog::Message << "A malformed " 11242 << Utils::getShaderStageString(static_cast<Utils::_shader_stage>(shader_stage)) 11243 << " compiled successfully " 11244 "(" 11245 << n_subroutine_types << " subroutine types " 11246 "were defined)." 11247 << tcu::TestLog::EndMessage; 11248 11249 m_has_test_passed = false; 11250 } 11251 11252 /* Release the object */ 11253 gl.deleteShader(m_so_id); 11254 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed."); 11255 } /* for (all test cases) */ 11256 } /* for (a number of different subroutine type declarations) */ 11257 } /* for (all shader stages) */ 11258 11259 /* Done */ 11260 if (m_has_test_passed) 11261 { 11262 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 11263 } 11264 else 11265 { 11266 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 11267 } 11268 11269 return STOP; 11270 } 11271 11272 /** Constructor. 11273 * 11274 * @param context Rendering context. 11275 * 11276 **/ 11277 NegativeTest5::NegativeTest5(deqp::Context& context) 11278 : TestCase(context, "subroutine_uniform_wo_matching_subroutines", 11279 "Verifies that a link- or compile-time error occurs when " 11280 "trying to link a program with no subroutine for subroutine " 11281 "uniform variable.") 11282 , m_fs_id(0) 11283 , m_gs_id(0) 11284 , m_has_test_passed(true) 11285 , m_po_id(0) 11286 , m_tc_id(0) 11287 , m_te_id(0) 11288 , m_vs_id(0) 11289 { 11290 /* Left blank intentionally */ 11291 } 11292 11293 /** Deinitializes all GL objects that may have been created during test execution */ 11294 void NegativeTest5::deinit() 11295 { 11296 deinitIteration(); 11297 } 11298 11299 /** Deinitializes all GL objects that may have been created during a single test 11300 * iteration. 11301 ***/ 11302 void NegativeTest5::deinitIteration() 11303 { 11304 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 11305 11306 if (m_fs_id != 0) 11307 { 11308 gl.deleteShader(m_fs_id); 11309 11310 m_fs_id = 0; 11311 } 11312 11313 if (m_gs_id != 0) 11314 { 11315 gl.deleteShader(m_gs_id); 11316 11317 m_gs_id = 0; 11318 } 11319 11320 if (m_po_id != 0) 11321 { 11322 gl.deleteProgram(m_po_id); 11323 11324 m_po_id = 0; 11325 } 11326 11327 if (m_tc_id != 0) 11328 { 11329 gl.deleteShader(m_tc_id); 11330 11331 m_tc_id = 0; 11332 } 11333 11334 if (m_te_id != 0) 11335 { 11336 gl.deleteShader(m_te_id); 11337 11338 m_te_id = 0; 11339 } 11340 11341 if (m_vs_id != 0) 11342 { 11343 gl.deleteShader(m_vs_id); 11344 11345 m_vs_id = 0; 11346 } 11347 } 11348 11349 /** Executes a single test iteration. 11350 * 11351 * If the iteration fails, m_has_test_passed will be set to false. 11352 * 11353 * @param shader_stage Shader stage, for which a subroutine uniform should be 11354 * declared in the shader without a matching subroutine. 11355 **/ 11356 void NegativeTest5::executeIteration(const Utils::_shader_stage& shader_stage) 11357 { 11358 std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT); 11359 std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY); 11360 std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); 11361 std::string te_body = 11362 getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); 11363 std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX); 11364 11365 if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body, 11366 DE_NULL, /* xfb_varyings */ 11367 DE_NULL, /* n_xfb_varyings */ 11368 &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) 11369 { 11370 /* None of the test programs should ever build successfully */ 11371 m_testCtx.getLog() << tcu::TestLog::Message 11372 << "A program object, consisting of the following shaders, has linked" 11373 " correctly. One of the shaders defines a subroutine uniform but does " 11374 "not implement any function that matches subroutine type of the uniform." 11375 " This should have resulted in a compilation/link-time error.\n" 11376 "\n" 11377 "Vertex shader:\n" 11378 "\n" 11379 << vs_body << "\n" 11380 "Tessellation control shader:\n" 11381 "\n" 11382 << tc_body << "\n" 11383 "Tessellation evaluation shader:\n" 11384 "\n" 11385 << te_body << "\n" 11386 "Geometry shader:\n" 11387 "\n" 11388 << gs_body << "\n" 11389 "Fragment shader:\n" 11390 "\n" 11391 << fs_body << tcu::TestLog::EndMessage; 11392 11393 m_has_test_passed = false; 11394 } 11395 } 11396 11397 /** Retrieves fragment shader body. 11398 * 11399 * @param include_invalid_subroutine_uniform_declaration true if the shader should declare 11400 * a subroutine uniform without 11401 * a matching subroutine, false otherwise. 11402 * 11403 * @return Requested string. 11404 **/ 11405 std::string NegativeTest5::getFragmentShaderBody(bool include_invalid_subroutine_uniform_declaration) const 11406 { 11407 std::stringstream result_sstream; 11408 11409 result_sstream << "#version 400\n" 11410 "\n" 11411 "#extension GL_ARB_shader_subroutine : require\n" 11412 "\n"; 11413 11414 if (include_invalid_subroutine_uniform_declaration) 11415 { 11416 result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n" 11417 "\n" 11418 "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n"; 11419 }; 11420 11421 result_sstream << "\n" 11422 "out vec4 result;\n" 11423 "\n" 11424 "void main()\n" 11425 "{\n"; 11426 11427 if (include_invalid_subroutine_uniform_declaration) 11428 { 11429 result_sstream << " test_subroutineFS(result);\n"; 11430 } 11431 else 11432 { 11433 result_sstream << " result = vec4(0, 1, 2, 3);\n"; 11434 } 11435 11436 result_sstream << "}\n"; 11437 11438 return result_sstream.str(); 11439 } 11440 11441 /** Retrieves geometry shader body. 11442 * 11443 * @param include_invalid_subroutine_uniform_declaration true if the shader should declare 11444 * a subroutine uniform without 11445 * a matching subroutine, false otherwise. 11446 * 11447 * @return Requested string. 11448 **/ 11449 std::string NegativeTest5::getGeometryShaderBody(bool include_invalid_subroutine_uniform_declaration) const 11450 { 11451 std::stringstream result_sstream; 11452 11453 result_sstream << "#version 400\n" 11454 "\n" 11455 "#extension GL_ARB_shader_subroutine : require\n" 11456 "\n" 11457 "layout (points) in;\n" 11458 "layout (points, max_vertices = 1) out;\n" 11459 "\n"; 11460 11461 if (include_invalid_subroutine_uniform_declaration) 11462 { 11463 result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n" 11464 "\n" 11465 "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n"; 11466 }; 11467 11468 result_sstream << "\n" 11469 "void main()\n" 11470 "{\n"; 11471 11472 if (include_invalid_subroutine_uniform_declaration) 11473 { 11474 result_sstream << " test_subroutineGS(gl_Position);\n"; 11475 } 11476 else 11477 { 11478 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 11479 } 11480 11481 result_sstream << "EmitVertex();\n" 11482 "}\n"; 11483 11484 return result_sstream.str(); 11485 } 11486 11487 /** Retrieves tessellation control shader body. 11488 * 11489 * @param include_invalid_subroutine_uniform_declaration true if the shader should declare 11490 * a subroutine uniform without 11491 * a matching subroutine, false otherwise. 11492 * 11493 * @return Requested string. 11494 **/ 11495 std::string NegativeTest5::getTessellationControlShaderBody(bool include_invalid_subroutine_uniform_declaration) const 11496 { 11497 std::stringstream result_sstream; 11498 11499 result_sstream << "#version 400\n" 11500 "\n" 11501 "#extension GL_ARB_shader_subroutine : require\n" 11502 "\n" 11503 "layout (vertices = 4) out;\n" 11504 "\n"; 11505 11506 if (include_invalid_subroutine_uniform_declaration) 11507 { 11508 result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n" 11509 "\n" 11510 "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n"; 11511 }; 11512 11513 result_sstream << "\n" 11514 "void main()\n" 11515 "{\n"; 11516 11517 if (include_invalid_subroutine_uniform_declaration) 11518 { 11519 result_sstream << " test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n"; 11520 } 11521 else 11522 { 11523 result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n"; 11524 } 11525 11526 result_sstream << "}\n"; 11527 11528 return result_sstream.str(); 11529 } 11530 11531 /** Retrieves tessellation evaluation body. 11532 * 11533 * @param include_invalid_subroutine_uniform_declaration true if the shader should declare 11534 * a subroutine uniform without 11535 * a matching subroutine, false otherwise. 11536 * 11537 * @return Requested string. 11538 **/ 11539 std::string NegativeTest5::getTessellationEvaluationShaderBody( 11540 bool include_invalid_subroutine_uniform_declaration) const 11541 { 11542 std::stringstream result_sstream; 11543 11544 result_sstream << "#version 400\n" 11545 "\n" 11546 "#extension GL_ARB_shader_subroutine : require\n" 11547 "\n" 11548 "layout (quads) in;\n" 11549 "\n"; 11550 11551 if (include_invalid_subroutine_uniform_declaration) 11552 { 11553 result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n" 11554 "\n" 11555 "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n"; 11556 }; 11557 11558 result_sstream << "\n" 11559 "void main()\n" 11560 "{\n"; 11561 11562 if (include_invalid_subroutine_uniform_declaration) 11563 { 11564 result_sstream << " test_subroutineTE(gl_Position);\n"; 11565 } 11566 else 11567 { 11568 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 11569 } 11570 11571 result_sstream << "}\n"; 11572 11573 return result_sstream.str(); 11574 } 11575 11576 /** Retrieves vertex shader body. 11577 * 11578 * @param include_invalid_subroutine_uniform_declaration true if the shader should declare 11579 * a subroutine uniform without 11580 * a matching subroutine, false otherwise. 11581 * 11582 * @return Requested string. 11583 **/ 11584 std::string NegativeTest5::getVertexShaderBody(bool include_invalid_subroutine_uniform_declaration) const 11585 { 11586 std::stringstream result_sstream; 11587 11588 result_sstream << "#version 400\n" 11589 "\n" 11590 "#extension GL_ARB_shader_subroutine : require\n" 11591 "\n"; 11592 11593 if (include_invalid_subroutine_uniform_declaration) 11594 { 11595 result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n" 11596 "\n" 11597 "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n"; 11598 }; 11599 11600 result_sstream << "\n" 11601 "void main()\n" 11602 "{\n"; 11603 11604 if (include_invalid_subroutine_uniform_declaration) 11605 { 11606 result_sstream << " test_subroutineVS(gl_Position);\n"; 11607 } 11608 else 11609 { 11610 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 11611 } 11612 11613 result_sstream << "}\n"; 11614 11615 return result_sstream.str(); 11616 } 11617 11618 /** Executes test iteration. 11619 * 11620 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 11621 */ 11622 tcu::TestNode::IterateResult NegativeTest5::iterate() 11623 { 11624 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 11625 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 11626 { 11627 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 11628 } 11629 11630 /* Iterate over all shader stages. Iteration-specific shader stage defines a subroutine type & 11631 * a corresponding subroutine uniform, for which no compatible subroutines are available. All 11632 * other shader stages are defined correctly. 11633 */ 11634 for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); 11635 shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) 11636 { 11637 executeIteration(static_cast<Utils::_shader_stage>(shader_stage)); 11638 deinitIteration(); 11639 } /* for (all shader stages) */ 11640 11641 /* All done */ 11642 if (m_has_test_passed) 11643 { 11644 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 11645 } 11646 else 11647 { 11648 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 11649 } 11650 11651 return STOP; 11652 } 11653 11654 /** Constructor. 11655 * 11656 * @param context Rendering context. 11657 * 11658 **/ 11659 NegativeTest6::NegativeTest6(deqp::Context& context) 11660 : TestCase(context, "two_duplicate_functions_one_being_a_subroutine", 11661 "Verifies that a link- or compile-time error occurs if any shader in " 11662 "a program object includes two functions with the same name and one " 11663 "of which is associated with a subroutine type.") 11664 , m_fs_id(0) 11665 , m_gs_id(0) 11666 , m_has_test_passed(true) 11667 , m_po_id(0) 11668 , m_tc_id(0) 11669 , m_te_id(0) 11670 , m_vs_id(0) 11671 { 11672 /* Left blank intentionally */ 11673 } 11674 11675 /** Deinitializes all GL objects that may have been created during test execution */ 11676 void NegativeTest6::deinit() 11677 { 11678 deinitIteration(); 11679 } 11680 11681 /** Deinitializes all GL objects that may have been created during a single test 11682 * iteration. 11683 ***/ 11684 void NegativeTest6::deinitIteration() 11685 { 11686 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 11687 11688 if (m_fs_id != 0) 11689 { 11690 gl.deleteShader(m_fs_id); 11691 11692 m_fs_id = 0; 11693 } 11694 11695 if (m_gs_id != 0) 11696 { 11697 gl.deleteShader(m_gs_id); 11698 11699 m_gs_id = 0; 11700 } 11701 11702 if (m_po_id != 0) 11703 { 11704 gl.deleteProgram(m_po_id); 11705 11706 m_po_id = 0; 11707 } 11708 11709 if (m_tc_id != 0) 11710 { 11711 gl.deleteShader(m_tc_id); 11712 11713 m_tc_id = 0; 11714 } 11715 11716 if (m_te_id != 0) 11717 { 11718 gl.deleteShader(m_te_id); 11719 11720 m_te_id = 0; 11721 } 11722 11723 if (m_vs_id != 0) 11724 { 11725 gl.deleteShader(m_vs_id); 11726 11727 m_vs_id = 0; 11728 } 11729 } 11730 11731 /** Executes a single test iteration. 11732 * 11733 * If the iteration fails, m_has_test_passed will be set to false. 11734 * 11735 * @param shader_stage Shader stage, for which two duplicate functions 11736 * (one additionally marked as subroutine) should 11737 * be defined. 11738 **/ 11739 void NegativeTest6::executeIteration(const Utils::_shader_stage& shader_stage) 11740 { 11741 std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT); 11742 std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY); 11743 std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); 11744 std::string te_body = 11745 getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); 11746 std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX); 11747 11748 if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body, 11749 DE_NULL, /* xfb_varyings */ 11750 DE_NULL, /* n_xfb_varyings */ 11751 &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) 11752 { 11753 /* None of the test programs should ever build successfully */ 11754 m_testCtx.getLog() << tcu::TestLog::Message 11755 << "A program object, consisting of the following shaders, has linked" 11756 " correctly. This is invalid, because one of the shaders defines two" 11757 " functions with the same name, with an exception that one of the" 11758 " functions is marked as a subroutine.\n" 11759 "\n" 11760 "Vertex shader:\n" 11761 "\n" 11762 << vs_body << "\n" 11763 "Tessellation control shader:\n" 11764 "\n" 11765 << tc_body << "\n" 11766 "Tessellation evaluation shader:\n" 11767 "\n" 11768 << te_body << "\n" 11769 "Geometry shader:\n" 11770 "\n" 11771 << gs_body << "\n" 11772 "Fragment shader:\n" 11773 "\n" 11774 << fs_body << tcu::TestLog::EndMessage; 11775 11776 m_has_test_passed = false; 11777 } 11778 } 11779 11780 /** Retrieves fragment shader body. 11781 * 11782 * @param include_invalid_declaration true if the shader should include duplicate function 11783 * declaration. 11784 * 11785 * @return Requested string. 11786 **/ 11787 std::string NegativeTest6::getFragmentShaderBody(bool include_invalid_declaration) const 11788 { 11789 std::stringstream result_sstream; 11790 11791 result_sstream << "#version 400\n" 11792 "\n" 11793 "#extension GL_ARB_shader_subroutine : require\n" 11794 "\n"; 11795 11796 if (include_invalid_declaration) 11797 { 11798 result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n" 11799 "\n" 11800 "subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test)\n" 11801 "{\n" 11802 " test = vec4(1, 2, 3, 4);\n" 11803 "}\n" 11804 "\n" 11805 "void test_impl1(out vec4 test)\n" 11806 "{\n" 11807 " test = vec4(2, 3, 4, 5);\n" 11808 "}\n" 11809 "\n" 11810 "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n"; 11811 }; 11812 11813 result_sstream << "\n" 11814 "out vec4 result;\n" 11815 "\n" 11816 "void main()\n" 11817 "{\n"; 11818 11819 if (include_invalid_declaration) 11820 { 11821 result_sstream << " test_subroutineFS(result);\n"; 11822 } 11823 else 11824 { 11825 result_sstream << " result = vec4(0, 1, 2, 3);\n"; 11826 } 11827 11828 result_sstream << "}\n"; 11829 11830 return result_sstream.str(); 11831 } 11832 11833 /** Retrieves geometry shader body. 11834 * 11835 * @param include_invalid_declaration true if the shader should include duplicate function 11836 * declaration. 11837 * 11838 * @return Requested string. 11839 **/ 11840 std::string NegativeTest6::getGeometryShaderBody(bool include_invalid_declaration) const 11841 { 11842 std::stringstream result_sstream; 11843 11844 result_sstream << "#version 400\n" 11845 "\n" 11846 "#extension GL_ARB_shader_subroutine : require\n" 11847 "\n" 11848 "layout (points) in;\n" 11849 "layout (points, max_vertices = 1) out;\n" 11850 "\n"; 11851 11852 if (include_invalid_declaration) 11853 { 11854 result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n" 11855 "\n" 11856 "subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test)\n" 11857 "{\n" 11858 " test = vec4(1, 2, 3, 4);\n" 11859 "}\n" 11860 "\n" 11861 "void test_impl1(out vec4 test)\n" 11862 "{\n" 11863 " test = vec4(2, 3, 4, 5);\n" 11864 "}\n" 11865 "\n" 11866 "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n"; 11867 }; 11868 11869 result_sstream << "\n" 11870 "void main()\n" 11871 "{\n"; 11872 11873 if (include_invalid_declaration) 11874 { 11875 result_sstream << " test_subroutineGS(gl_Position);\n"; 11876 } 11877 else 11878 { 11879 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 11880 } 11881 11882 result_sstream << "EmitVertex();\n" 11883 "}\n"; 11884 11885 return result_sstream.str(); 11886 } 11887 11888 /** Retrieves tessellation control shader body. 11889 * 11890 * @param include_invalid_declaration true if the shader should include duplicate function 11891 * declaration. 11892 * 11893 * @return Requested string. 11894 **/ 11895 std::string NegativeTest6::getTessellationControlShaderBody(bool include_invalid_declaration) const 11896 { 11897 std::stringstream result_sstream; 11898 11899 result_sstream << "#version 400\n" 11900 "\n" 11901 "#extension GL_ARB_shader_subroutine : require\n" 11902 "\n" 11903 "layout (vertices = 4) out;\n" 11904 "\n"; 11905 11906 if (include_invalid_declaration) 11907 { 11908 result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n" 11909 "\n" 11910 "subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test)\n" 11911 "{\n" 11912 " test = vec4(1, 2, 3, 4);\n" 11913 "}\n" 11914 "\n" 11915 "void test_impl1(out vec4 test)\n" 11916 "{\n" 11917 " test = vec4(2, 3, 4, 5);\n" 11918 "}\n" 11919 "\n" 11920 "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n"; 11921 }; 11922 11923 result_sstream << "\n" 11924 "void main()\n" 11925 "{\n"; 11926 11927 if (include_invalid_declaration) 11928 { 11929 result_sstream << " test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n"; 11930 } 11931 else 11932 { 11933 result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n"; 11934 } 11935 11936 result_sstream << "}\n"; 11937 11938 return result_sstream.str(); 11939 } 11940 11941 /** Retrieves tessellation evaluation body. 11942 * 11943 * @param include_invalid_declaration true if the shader should include duplicate function 11944 * declaration. 11945 * 11946 * @return Requested string. 11947 **/ 11948 std::string NegativeTest6::getTessellationEvaluationShaderBody(bool include_invalid_declaration) const 11949 { 11950 std::stringstream result_sstream; 11951 11952 result_sstream << "#version 400\n" 11953 "\n" 11954 "#extension GL_ARB_shader_subroutine : require\n" 11955 "\n" 11956 "layout (quads) in;\n" 11957 "\n"; 11958 11959 if (include_invalid_declaration) 11960 { 11961 result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n" 11962 "\n" 11963 "subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test)\n" 11964 "{\n" 11965 " test = vec4(1, 2, 3, 4);\n" 11966 "}\n" 11967 "\n" 11968 "void test_impl1(out vec4 test)\n" 11969 "{\n" 11970 " test = vec4(2, 3, 4, 5);\n" 11971 "}\n" 11972 "\n" 11973 "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n"; 11974 }; 11975 11976 result_sstream << "\n" 11977 "void main()\n" 11978 "{\n"; 11979 11980 if (include_invalid_declaration) 11981 { 11982 result_sstream << " test_subroutineTE(gl_Position);\n"; 11983 } 11984 else 11985 { 11986 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 11987 } 11988 11989 result_sstream << "}\n"; 11990 11991 return result_sstream.str(); 11992 } 11993 11994 /** Retrieves vertex shader body. 11995 * 11996 * @param include_invalid_declaration true if the shader should include duplicate function 11997 * declaration. 11998 * 11999 * @return Requested string. 12000 **/ 12001 std::string NegativeTest6::getVertexShaderBody(bool include_invalid_declaration) const 12002 { 12003 std::stringstream result_sstream; 12004 12005 result_sstream << "#version 400\n" 12006 "\n" 12007 "#extension GL_ARB_shader_subroutine : require\n" 12008 "\n"; 12009 12010 if (include_invalid_declaration) 12011 { 12012 result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n" 12013 "\n" 12014 "subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test)\n" 12015 "{\n" 12016 " test = vec4(1, 2, 3, 4);\n" 12017 "}\n" 12018 "\n" 12019 "void test_impl1(out vec4 test)\n" 12020 "{\n" 12021 " test = vec4(2, 3, 4, 5);\n" 12022 "}\n" 12023 "\n" 12024 "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n"; 12025 }; 12026 12027 result_sstream << "\n" 12028 "void main()\n" 12029 "{\n"; 12030 12031 if (include_invalid_declaration) 12032 { 12033 result_sstream << " test_subroutineVS(gl_Position);\n"; 12034 } 12035 else 12036 { 12037 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 12038 } 12039 12040 result_sstream << "}\n"; 12041 12042 return result_sstream.str(); 12043 } 12044 12045 /** Executes test iteration. 12046 * 12047 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 12048 */ 12049 tcu::TestNode::IterateResult NegativeTest6::iterate() 12050 { 12051 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 12052 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 12053 { 12054 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 12055 } 12056 12057 /* Iterate over all shader stages. In each iteration, we will inject invalid 12058 * duplicate function declarations to iteration-specific shader stage. All other 12059 * shader stages will be assigned valid bodies. Test should fail if the program 12060 * links successfully. 12061 */ 12062 for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); 12063 shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) 12064 { 12065 executeIteration(static_cast<Utils::_shader_stage>(shader_stage)); 12066 deinitIteration(); 12067 } /* for (all shader stages) */ 12068 12069 /* All done */ 12070 if (m_has_test_passed) 12071 { 12072 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 12073 } 12074 else 12075 { 12076 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 12077 } 12078 12079 return STOP; 12080 } 12081 12082 /** Constructor 12083 * 12084 * @param context CTS context 12085 **/ 12086 NegativeTest7::NegativeTest7(deqp::Context& context) 12087 : TestCase(context, "recursion", "Verify that it is not possible to build program with recursing subroutines") 12088 , m_program_id(0) 12089 , m_vertex_shader_id(0) 12090 { 12091 /* Nothing to be done here */ 12092 } 12093 12094 /** Deinitializes all GL objects that may have been created during test execution 12095 * 12096 **/ 12097 void NegativeTest7::deinit() 12098 { 12099 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 12100 12101 if (m_program_id != 0) 12102 { 12103 gl.deleteProgram(m_program_id); 12104 12105 m_program_id = 0; 12106 } 12107 12108 if (m_vertex_shader_id != 0) 12109 { 12110 gl.deleteShader(m_vertex_shader_id); 12111 12112 m_vertex_shader_id = 0; 12113 } 12114 } 12115 12116 /** Executes test iteration. 12117 * 12118 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 12119 **/ 12120 tcu::TestNode::IterateResult NegativeTest7::iterate() 12121 { 12122 static const GLchar* vertex_shader_with_static_recursion = 12123 "#version 400\n" 12124 "\n" 12125 "#extension GL_ARB_shader_subroutine : require\n" 12126 "\n" 12127 "precision highp float;\n" 12128 "\n" 12129 "subroutine vec4 routine_type(in vec4 data, in uint control);\n" 12130 "\n" 12131 "subroutine (routine_type) vec4 power_routine(in vec4 data, in uint control)\n" 12132 "{\n" 12133 " if (0 != control)\n" 12134 " {\n" 12135 " return data * power_routine(data, control - 1);\n" 12136 " }\n" 12137 " else\n" 12138 " {\n" 12139 " return vec4(1, 1, 1, 1);\n" 12140 " }\n" 12141 "}\n" 12142 "\n" 12143 "subroutine (routine_type) vec4 select_routine(in vec4 data, in uint control)\n" 12144 "{\n" 12145 " if (0 == control)\n" 12146 " {\n" 12147 " return data.rrrr;\n" 12148 " }\n" 12149 " else if (1 == control)\n" 12150 " {\n" 12151 " return data.gggg;\n" 12152 " }\n" 12153 " else if (2 == control)\n" 12154 " {\n" 12155 " return data.bbbb;\n" 12156 " }\n" 12157 " else\n" 12158 " {\n" 12159 " return data.aaaa;\n" 12160 " }\n" 12161 "}\n" 12162 "\n" 12163 "subroutine uniform routine_type routine;\n" 12164 "\n" 12165 "uniform vec4 uni_value;\n" 12166 "uniform uint uni_control;\n" 12167 "\n" 12168 "out vec4 out_result;\n" 12169 "\n" 12170 "void main()\n" 12171 "{\n" 12172 " out_result = routine(uni_value, uni_control);\n" 12173 "}\n" 12174 "\n"; 12175 12176 static const GLchar* vertex_shader_with_dynamic_recursion = 12177 "#version 400\n" 12178 "\n" 12179 "#extension GL_ARB_shader_subroutine : require\n" 12180 "\n" 12181 "precision highp float;\n" 12182 "\n" 12183 "subroutine vec4 routine_type(in vec4 data);\n" 12184 "\n" 12185 "subroutine uniform routine_type routine;\n" 12186 "\n" 12187 "subroutine (routine_type) vec4 div_by_2(in vec4 data)\n" 12188 "{\n" 12189 " return data / 2;\n" 12190 "}\n" 12191 "\n" 12192 "subroutine (routine_type) vec4 div_routine_result_by_2(in vec4 data)\n" 12193 "{\n" 12194 " return routine(data) / 2;\n" 12195 "}\n" 12196 "\n" 12197 "uniform vec4 uni_value;\n" 12198 "\n" 12199 "out vec4 out_result;\n" 12200 "\n" 12201 "void main()\n" 12202 "{\n" 12203 " out_result = routine(uni_value);\n" 12204 "}\n" 12205 "\n"; 12206 12207 static const GLchar* vertex_shader_with_subroutine_function_recursion = 12208 "#version 400\n" 12209 "\n" 12210 "#extension GL_ARB_shader_subroutine : require\n" 12211 "\n" 12212 "precision highp float;\n" 12213 "\n" 12214 "subroutine vec4 routine_type(in vec4 data);\n" 12215 "\n" 12216 "subroutine uniform routine_type routine;\n" 12217 "\n" 12218 "vec4 function(in vec4 data)\n" 12219 "{\n" 12220 " return routine(data) + vec4(0.5, 0.5, 0.5, 0.5);\n" 12221 "}\n" 12222 "\n" 12223 "subroutine (routine_type) vec4 routine_a(in vec4 data)\n" 12224 "{\n" 12225 " return function(data) / 2;\n" 12226 "}\n" 12227 "\n" 12228 "subroutine (routine_type) vec4 routine_b(in vec4 data)\n" 12229 "{\n" 12230 " return routine_a(data) * 2;\n" 12231 "}\n" 12232 "\n" 12233 "uniform vec4 uni_value;\n" 12234 "\n" 12235 "out vec4 out_result;\n" 12236 "\n" 12237 "void main()\n" 12238 "{\n" 12239 " out_result = routine(uni_value);\n" 12240 "}\n" 12241 "\n"; 12242 12243 bool result = true; 12244 12245 if (false == test(vertex_shader_with_subroutine_function_recursion, "routine_a")) 12246 { 12247 result = false; 12248 } 12249 12250 if (false == test(vertex_shader_with_dynamic_recursion, "div_routine_result_by_2")) 12251 { 12252 result = false; 12253 } 12254 12255 if (false == test(vertex_shader_with_static_recursion, "power_routine")) 12256 { 12257 result = false; 12258 } 12259 12260 /* Set result */ 12261 if (true == result) 12262 { 12263 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 12264 } 12265 else 12266 { 12267 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 12268 } 12269 12270 /* Done */ 12271 return tcu::TestNode::STOP; 12272 } 12273 12274 /** Try to build program from vertex shader code. 12275 * 12276 * @param vertex_shader_code Source code of vertex shader 12277 * @param name_of_recursive_routine Name of subroutine that should cause link failure due to recursion 12278 * 12279 * @return true build process failed, false otherwise 12280 **/ 12281 bool NegativeTest7::test(const GLchar* vertex_shader_code, const GLchar* name_of_recursive_routine) 12282 { 12283 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 12284 bool result = true; 12285 static const GLchar* varying_name = "out_result"; 12286 12287 /* Try to build program */ 12288 if (true == Utils::buildProgram(gl, vertex_shader_code, "", "", "", "", &varying_name /* varying_names */, 12289 1 /* n_varyings */, &m_vertex_shader_id, 0, 0, 0, 0, &m_program_id)) 12290 { 12291 /* Success is considered an error */ 12292 12293 Utils::program program(m_context); 12294 GLuint index = 0; 12295 12296 program.build(0, 0, 0, 0, 0, vertex_shader_code, 0, 0); 12297 12298 /* Verify that recursive subroutine is active */ 12299 try 12300 { 12301 index = program.getSubroutineIndex(name_of_recursive_routine, GL_VERTEX_SHADER); 12302 } 12303 catch (const std::exception& exc) 12304 { 12305 /* Something wrong with shader or compilation */ 12306 m_context.getTestContext().getLog() 12307 << tcu::TestLog::Message << "It is expected that subroutine: \n" 12308 << name_of_recursive_routine 12309 << " is considered active. This subroutine is potentially recursive and should cause link failure." 12310 << tcu::TestLog::EndMessage; 12311 12312 throw exc; 12313 } 12314 12315 /* Subsoutine is active, however linking should fail */ 12316 m_context.getTestContext().getLog() 12317 << tcu::TestLog::Message << "Error. Program with potentially recursive subroutine, " 12318 << name_of_recursive_routine << ", which is active, index: " << index << ", has been built successfully.\n" 12319 << vertex_shader_code << tcu::TestLog::EndMessage; 12320 12321 result = false; 12322 } 12323 12324 /* Delete program and shader */ 12325 deinit(); 12326 12327 /* Done */ 12328 return result; 12329 } 12330 12331 /** Constructor. 12332 * 12333 * @param context Rendering context. 12334 * 12335 **/ 12336 NegativeTest8::NegativeTest8(deqp::Context& context) 12337 : TestCase(context, "subroutine_wo_body", "Verifies that a compile- or link-time error occurs if a function " 12338 "declared as a subroutine does not include a body.") 12339 , m_fs_id(0) 12340 , m_gs_id(0) 12341 , m_has_test_passed(true) 12342 , m_po_id(0) 12343 , m_tc_id(0) 12344 , m_te_id(0) 12345 , m_vs_id(0) 12346 { 12347 /* Left blank intentionally */ 12348 } 12349 12350 /** Deinitializes all GL objects that may have been created during test execution */ 12351 void NegativeTest8::deinit() 12352 { 12353 deinitIteration(); 12354 } 12355 12356 /** Deinitializes all GL objects that may have been created during a single test 12357 * iteration. 12358 ***/ 12359 void NegativeTest8::deinitIteration() 12360 { 12361 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 12362 12363 if (m_fs_id != 0) 12364 { 12365 gl.deleteShader(m_fs_id); 12366 12367 m_fs_id = 0; 12368 } 12369 12370 if (m_gs_id != 0) 12371 { 12372 gl.deleteShader(m_gs_id); 12373 12374 m_gs_id = 0; 12375 } 12376 12377 if (m_po_id != 0) 12378 { 12379 gl.deleteProgram(m_po_id); 12380 12381 m_po_id = 0; 12382 } 12383 12384 if (m_tc_id != 0) 12385 { 12386 gl.deleteShader(m_tc_id); 12387 12388 m_tc_id = 0; 12389 } 12390 12391 if (m_te_id != 0) 12392 { 12393 gl.deleteShader(m_te_id); 12394 12395 m_te_id = 0; 12396 } 12397 12398 if (m_vs_id != 0) 12399 { 12400 gl.deleteShader(m_vs_id); 12401 12402 m_vs_id = 0; 12403 } 12404 } 12405 12406 /** Executes a single test iteration. 12407 * 12408 * If the iteration fails, m_has_test_passed will be set to false. 12409 * 12410 * @param shader_stage Shader stage, for which two duplicate functions 12411 * (one additionally marked as subroutine) should 12412 * be defined. 12413 **/ 12414 void NegativeTest8::executeIteration(const Utils::_shader_stage& shader_stage) 12415 { 12416 std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT); 12417 std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY); 12418 std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); 12419 std::string te_body = 12420 getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); 12421 std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX); 12422 12423 if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body, 12424 DE_NULL, /* xfb_varyings */ 12425 DE_NULL, /* n_xfb_varyings */ 12426 &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) 12427 { 12428 /* None of the test programs should ever build successfully */ 12429 m_testCtx.getLog() << tcu::TestLog::Message 12430 << "A program object consisting of FS+GS+TC+TE+VS stages has linked successfully, " 12431 "even though one of the shaders only defines a subroutine that lacks any body." 12432 "\n" 12433 "Vertex shader:\n" 12434 "\n" 12435 << vs_body << "\n" 12436 "Tessellation control shader:\n" 12437 "\n" 12438 << tc_body << "\n" 12439 "Tessellation evaluation shader:\n" 12440 "\n" 12441 << te_body << "\n" 12442 "Geometry shader:\n" 12443 "\n" 12444 << gs_body << "\n" 12445 "Fragment shader:\n" 12446 "\n" 12447 << fs_body << tcu::TestLog::EndMessage; 12448 12449 m_has_test_passed = false; 12450 } 12451 } 12452 12453 /** Retrieves fragment shader body. 12454 * 12455 * @param include_invalid_declaration true if a subroutine prototype should be included in 12456 * the shader, false to skip it. 12457 * 12458 * @return Requested string. 12459 **/ 12460 std::string NegativeTest8::getFragmentShaderBody(bool include_invalid_declaration) const 12461 { 12462 std::stringstream result_sstream; 12463 12464 result_sstream << "#version 400\n" 12465 "\n" 12466 "#extension GL_ARB_shader_subroutine : require\n" 12467 "\n"; 12468 12469 if (include_invalid_declaration) 12470 { 12471 result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n" 12472 "\n" 12473 "subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test);\n" 12474 "\n" 12475 "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n"; 12476 }; 12477 12478 result_sstream << "\n" 12479 "out vec4 result;\n" 12480 "\n" 12481 "void main()\n" 12482 "{\n"; 12483 12484 if (include_invalid_declaration) 12485 { 12486 result_sstream << " test_subroutineFS(result);\n"; 12487 } 12488 else 12489 { 12490 result_sstream << " result = vec4(0, 1, 2, 3);\n"; 12491 } 12492 12493 result_sstream << "}\n"; 12494 12495 return result_sstream.str(); 12496 } 12497 12498 /** Retrieves geometry shader body. 12499 * 12500 * @param include_invalid_declaration true if a subroutine prototype should be included in 12501 * the shader, false to skip it. 12502 * 12503 * @return Requested string. 12504 **/ 12505 std::string NegativeTest8::getGeometryShaderBody(bool include_invalid_declaration) const 12506 { 12507 std::stringstream result_sstream; 12508 12509 result_sstream << "#version 400\n" 12510 "\n" 12511 "#extension GL_ARB_shader_subroutine : require\n" 12512 "\n" 12513 "layout (points) in;\n" 12514 "layout (points, max_vertices = 1) out;\n" 12515 "\n"; 12516 12517 if (include_invalid_declaration) 12518 { 12519 result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n" 12520 "\n" 12521 "subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test);\n" 12522 "\n" 12523 "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n"; 12524 }; 12525 12526 result_sstream << "\n" 12527 "void main()\n" 12528 "{\n"; 12529 12530 if (include_invalid_declaration) 12531 { 12532 result_sstream << " test_subroutineGS(gl_Position);\n"; 12533 } 12534 else 12535 { 12536 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 12537 } 12538 12539 result_sstream << "EmitVertex();\n" 12540 "}\n"; 12541 12542 return result_sstream.str(); 12543 } 12544 12545 /** Retrieves tessellation control shader body. 12546 * 12547 * @param include_invalid_declaration true if a subroutine prototype should be included in 12548 * the shader, false to skip it. 12549 * 12550 * @return Requested string. 12551 **/ 12552 std::string NegativeTest8::getTessellationControlShaderBody(bool include_invalid_declaration) const 12553 { 12554 std::stringstream result_sstream; 12555 12556 result_sstream << "#version 400\n" 12557 "\n" 12558 "#extension GL_ARB_shader_subroutine : require\n" 12559 "\n" 12560 "layout (vertices = 4) out;\n" 12561 "\n"; 12562 12563 if (include_invalid_declaration) 12564 { 12565 result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n" 12566 "\n" 12567 "subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test);\n" 12568 "\n" 12569 "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n"; 12570 }; 12571 12572 result_sstream << "\n" 12573 "void main()\n" 12574 "{\n"; 12575 12576 if (include_invalid_declaration) 12577 { 12578 result_sstream << " test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n"; 12579 } 12580 else 12581 { 12582 result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n"; 12583 } 12584 12585 result_sstream << "}\n"; 12586 12587 return result_sstream.str(); 12588 } 12589 12590 /** Retrieves tessellation evaluation body. 12591 * 12592 * @param include_invalid_declaration true if a subroutine prototype should be included in 12593 * the shader, false to skip it. 12594 * 12595 * @return Requested string. 12596 **/ 12597 std::string NegativeTest8::getTessellationEvaluationShaderBody(bool include_invalid_declaration) const 12598 { 12599 std::stringstream result_sstream; 12600 12601 result_sstream << "#version 400\n" 12602 "\n" 12603 "#extension GL_ARB_shader_subroutine : require\n" 12604 "\n" 12605 "layout (quads) in;\n" 12606 "\n"; 12607 12608 if (include_invalid_declaration) 12609 { 12610 result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n" 12611 "\n" 12612 "subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test);\n" 12613 "\n" 12614 "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n"; 12615 }; 12616 12617 result_sstream << "\n" 12618 "void main()\n" 12619 "{\n"; 12620 12621 if (include_invalid_declaration) 12622 { 12623 result_sstream << " test_subroutineTE(gl_Position);\n"; 12624 } 12625 else 12626 { 12627 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 12628 } 12629 12630 result_sstream << "}\n"; 12631 12632 return result_sstream.str(); 12633 } 12634 12635 /** Retrieves vertex shader body. 12636 * 12637 * @param include_invalid_declaration true if a subroutine prototype should be included in 12638 * the shader, false to skip it. 12639 * 12640 * @return Requested string. 12641 **/ 12642 std::string NegativeTest8::getVertexShaderBody(bool include_invalid_declaration) const 12643 { 12644 std::stringstream result_sstream; 12645 12646 result_sstream << "#version 400\n" 12647 "\n" 12648 "#extension GL_ARB_shader_subroutine : require\n" 12649 "\n"; 12650 12651 if (include_invalid_declaration) 12652 { 12653 result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n" 12654 "\n" 12655 "subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test);\n" 12656 "\n" 12657 "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n"; 12658 }; 12659 12660 result_sstream << "\n" 12661 "void main()\n" 12662 "{\n"; 12663 12664 if (include_invalid_declaration) 12665 { 12666 result_sstream << " test_subroutineVS(gl_Position);\n"; 12667 } 12668 else 12669 { 12670 result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; 12671 } 12672 12673 result_sstream << "}\n"; 12674 12675 return result_sstream.str(); 12676 } 12677 12678 /** Executes test iteration. 12679 * 12680 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 12681 */ 12682 tcu::TestNode::IterateResult NegativeTest8::iterate() 12683 { 12684 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 12685 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 12686 { 12687 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 12688 } 12689 12690 /* Iterate over all shader stages. For each iteration, iteration-specific shader stage 12691 * will feature an invalid subroutine definition. Other shader stages will be assigned 12692 * valid bodies. The test fails if a program built of such shaders links successfully. 12693 */ 12694 for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); 12695 shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) 12696 { 12697 executeIteration(static_cast<Utils::_shader_stage>(shader_stage)); 12698 deinitIteration(); 12699 } /* for (all shader stages) */ 12700 12701 /* All done */ 12702 if (m_has_test_passed) 12703 { 12704 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 12705 } 12706 else 12707 { 12708 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 12709 } 12710 12711 return STOP; 12712 } 12713 12714 /** Constructor. 12715 * 12716 * @param context Rendering context. 12717 **/ 12718 NegativeTest9::NegativeTest9(deqp::Context& context) 12719 : TestCase(context, "subroutines_cannot_be_assigned_float_int_values_or_be_compared", 12720 "Make sure it is not possible to assign float/int to subroutine " 12721 "uniform and that subroutine uniform values cannot be compared.") 12722 , m_has_test_passed(true) 12723 , m_po_id(0) 12724 , m_vs_id(0) 12725 { 12726 /* Left blank intentionally */ 12727 } 12728 12729 /** Deinitializes any GL objects that may have been created during 12730 * test execution. 12731 **/ 12732 void NegativeTest9::deinit() 12733 { 12734 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 12735 12736 if (m_po_id != 0) 12737 { 12738 gl.deleteProgram(m_po_id); 12739 12740 m_po_id = 0; 12741 } 12742 12743 if (m_vs_id != 0) 12744 { 12745 gl.deleteShader(m_vs_id); 12746 12747 m_vs_id = 0; 12748 } 12749 } 12750 12751 /** Returns a literal corresponding to user-specified test case enum. 12752 * 12753 * @param test_case As per description. 12754 * 12755 * @return Requested string. 12756 **/ 12757 std::string NegativeTest9::getTestCaseString(const _test_case& test_case) 12758 { 12759 std::string result = "?"; 12760 12761 switch (test_case) 12762 { 12763 case TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: 12764 result = "TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT"; 12765 break; 12766 case TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: 12767 result = "TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT"; 12768 break; 12769 case TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON: 12770 result = "TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON"; 12771 break; 12772 default: 12773 break; 12774 } 12775 12776 return result; 12777 } 12778 12779 /** Retrieves vertex shader body for user-specified test case. 12780 * 12781 * @param test_case As per description. 12782 * 12783 * @return Requested string. 12784 **/ 12785 std::string NegativeTest9::getVertexShader(const _test_case& test_case) 12786 { 12787 std::stringstream result_sstream; 12788 12789 /* Form pre-amble */ 12790 result_sstream << "#version 400\n" 12791 "\n" 12792 "#extension GL_ARB_shader_subroutine : require\n" 12793 "\n" 12794 /* Define a subroutine */ 12795 "subroutine void subroutineType(inout vec4 test);\n" 12796 "\n" 12797 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 12798 "{\n" 12799 " test += vec4(0, 1, 2, 3);\n" 12800 "}\n" 12801 "\n" 12802 "subroutine uniform subroutineType function;\n" 12803 "\n"; 12804 12805 /* Include case-specific implementation */ 12806 switch (test_case) 12807 { 12808 case TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: 12809 { 12810 result_sstream << "void main()\n" 12811 "{\n" 12812 " function = 1.0f;\n" 12813 "\n" 12814 " function(gl_Position);\n" 12815 "}\n"; 12816 12817 break; 12818 } 12819 12820 case TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: 12821 { 12822 result_sstream << "void main()\n" 12823 "{\n" 12824 " function = 1;\n" 12825 "\n" 12826 " function(gl_Position);\n" 12827 "}\n"; 12828 12829 break; 12830 } 12831 12832 case TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON: 12833 { 12834 result_sstream << "subroutine uniform subroutineType function2;\n" 12835 "\n" 12836 "void main()\n" 12837 "{\n" 12838 " if (function == function2)\n" 12839 " {\n" 12840 " function(gl_Position);\n" 12841 " }\n" 12842 " else\n" 12843 " {\n" 12844 " function2(gl_Position);\n" 12845 " }\n" 12846 "}\n"; 12847 12848 break; 12849 } 12850 12851 default: 12852 break; 12853 } /* switch (test_case) */ 12854 12855 /* Done */ 12856 return result_sstream.str(); 12857 } 12858 12859 /** Executes test iteration. 12860 * 12861 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 12862 */ 12863 tcu::TestNode::IterateResult NegativeTest9::iterate() 12864 { 12865 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 12866 12867 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 12868 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 12869 { 12870 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 12871 } 12872 12873 /* Iterate over all test cases */ 12874 for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) 12875 { 12876 /* Try to build a program object using invalid vertex shader, specific to the 12877 * iteration we're currently in */ 12878 std::string vs_body = getVertexShader(static_cast<_test_case>(test_case)); 12879 12880 if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "", /* tc_body */ 12881 "", /* te_body */ 12882 "", /* gs_body */ 12883 "", /* fs_body */ 12884 DE_NULL, /* xfb_varyings */ 12885 0, /* n_xfb_varyings */ 12886 &m_vs_id, DE_NULL, /* out_tc_id */ 12887 DE_NULL, /* out_te_id */ 12888 DE_NULL, /* out_gs_id */ 12889 DE_NULL, /* out_fs_id */ 12890 &m_po_id)) 12891 { 12892 m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" 12893 << getTestCaseString(static_cast<_test_case>(test_case)) 12894 << "] test case, even though it was invalid." << tcu::TestLog::EndMessage; 12895 12896 m_has_test_passed = false; 12897 } 12898 12899 /* Delete any objects that may have been created */ 12900 deinit(); 12901 } /* for (all test cases) */ 12902 12903 /** All done */ 12904 if (m_has_test_passed) 12905 { 12906 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 12907 } 12908 else 12909 { 12910 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 12911 } 12912 12913 return STOP; 12914 } 12915 12916 /** Constructor. 12917 * 12918 * @param context Rendering context. 12919 **/ 12920 NegativeTest10::NegativeTest10(deqp::Context& context) 12921 : TestCase(context, "function_overloading_forbidden_for_subroutines", 12922 "Check that an overloaded function cannot be declared with subroutine and " 12923 "a program will fail to compile or link if any shader or stage contains" 12924 " two or more functions with the same name if the name is associated with" 12925 " a subroutine type.") 12926 , m_has_test_passed(true) 12927 , m_fs_id(0) 12928 , m_gs_id(0) 12929 , m_po_id(0) 12930 , m_tc_id(0) 12931 , m_te_id(0) 12932 , m_vs_id(0) 12933 { 12934 /* Left blank intentionally */ 12935 } 12936 12937 /** Deinitializes any GL objects that may have been created during 12938 * test execution. 12939 **/ 12940 void NegativeTest10::deinit() 12941 { 12942 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 12943 12944 if (m_fs_id != 0) 12945 { 12946 gl.deleteShader(m_fs_id); 12947 12948 m_fs_id = 0; 12949 } 12950 12951 if (m_gs_id != 0) 12952 { 12953 gl.deleteShader(m_gs_id); 12954 12955 m_gs_id = 0; 12956 } 12957 12958 if (m_po_id != 0) 12959 { 12960 gl.deleteProgram(m_po_id); 12961 12962 m_po_id = 0; 12963 } 12964 12965 if (m_tc_id != 0) 12966 { 12967 gl.deleteShader(m_tc_id); 12968 12969 m_tc_id = 0; 12970 } 12971 12972 if (m_te_id != 0) 12973 { 12974 gl.deleteShader(m_te_id); 12975 12976 m_te_id = 0; 12977 } 12978 12979 if (m_vs_id != 0) 12980 { 12981 gl.deleteShader(m_vs_id); 12982 12983 m_vs_id = 0; 12984 } 12985 } 12986 12987 /** Retrieves fragment shader that should be used for the purpose of the test. 12988 * An overloaded version of a subroutine function is inserted if 12989 * @param include_duplicate_function flag is set to true. 12990 * 12991 * @param include_duplicate_function As per description. 12992 * 12993 * @return Requested string. 12994 **/ 12995 std::string NegativeTest10::getFragmentShader(bool include_duplicate_function) 12996 { 12997 std::stringstream result_sstream; 12998 12999 result_sstream << "#version 400\n" 13000 "\n" 13001 "#extension GL_ARB_shader_subroutine : require\n" 13002 "\n" 13003 "subroutine void subroutineType(inout vec4 test);\n" 13004 "\n" 13005 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13006 "{\n" 13007 " test = vec4(2, 3, 4, 5);\n" 13008 "}\n" 13009 "\n" 13010 "subroutine uniform subroutineType function;\n" 13011 "out vec4 result;\n" 13012 "\n"; 13013 13014 if (include_duplicate_function) 13015 { 13016 result_sstream << "void test_function(inout vec4 test)\n" 13017 "{\n" 13018 " test = vec4(3, 4, 5, 6);\n" 13019 "}\n" 13020 "\n"; 13021 } 13022 13023 result_sstream << "void main()\n" 13024 "{\n" 13025 " test_function(result);\n" 13026 "}\n"; 13027 13028 return result_sstream.str(); 13029 } 13030 13031 /** Retrieves geometry shader that should be used for the purpose of the test. 13032 * An overloaded version of a subroutine function is inserted if 13033 * @param include_duplicate_function flag is set to true. 13034 * 13035 * @param include_duplicate_function As per description. 13036 * 13037 * @return Requested string. 13038 **/ 13039 std::string NegativeTest10::getGeometryShader(bool include_duplicate_function) 13040 { 13041 std::stringstream result_sstream; 13042 13043 result_sstream << "#version 400\n" 13044 "\n" 13045 "#extension GL_ARB_shader_subroutine : require\n" 13046 "\n" 13047 "layout (triangles) in;\n" 13048 "layout (triangle_strip, max_vertices = 4) out;\n" 13049 "\n" 13050 "subroutine void subroutineType(inout vec4 test);\n" 13051 "\n" 13052 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13053 "{\n" 13054 " test = vec4(2, 3, 4, 5);\n" 13055 "}\n" 13056 "\n" 13057 "subroutine uniform subroutineType function;\n" 13058 "\n"; 13059 13060 if (include_duplicate_function) 13061 { 13062 result_sstream << "void test_function(inout vec4 test)\n" 13063 "{\n" 13064 " test = vec4(3, 4, 5, 6);\n" 13065 "}\n" 13066 "\n"; 13067 } 13068 13069 result_sstream << "void main()\n" 13070 "{\n" 13071 " function(gl_Position);\n" 13072 " EmitVertex();\n" 13073 " EndPrimitive();\n" 13074 "}\n"; 13075 13076 return result_sstream.str(); 13077 } 13078 13079 /** Retrieves tess control shader that should be used for the purpose of the test. 13080 * An overloaded version of a subroutine function is inserted if 13081 * @param include_duplicate_function flag is set to true. 13082 * 13083 * @param include_duplicate_function As per description. 13084 * 13085 * @return Requested string. 13086 **/ 13087 std::string NegativeTest10::getTessellationControlShader(bool include_duplicate_function) 13088 { 13089 std::stringstream result_sstream; 13090 13091 result_sstream << "#version 400\n" 13092 "\n" 13093 "#extension GL_ARB_shader_subroutine : require\n" 13094 "\n" 13095 "layout (vertices = 4) out;\n" 13096 "\n" 13097 "subroutine void subroutineType(inout vec4 test);\n" 13098 "\n" 13099 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13100 "{\n" 13101 " test = vec4(2, 3, 4, 5);\n" 13102 "}\n" 13103 "\n" 13104 "subroutine uniform subroutineType function;\n" 13105 "\n"; 13106 13107 if (include_duplicate_function) 13108 { 13109 result_sstream << "void test_function(inout vec4 test)\n" 13110 "{\n" 13111 " test = vec4(3, 4, 5, 6);\n" 13112 "}\n" 13113 "\n"; 13114 } 13115 13116 result_sstream << "void main()\n" 13117 "{\n" 13118 " vec4 temp;\n" 13119 "\n" 13120 " function(temp);\n" 13121 "\n" 13122 " gl_out[gl_InvocationID].gl_Position = temp;\n" 13123 " gl_TessLevelInner[0] = temp.x;\n" 13124 " gl_TessLevelInner[1] = temp.y;\n" 13125 " gl_TessLevelOuter[0] = temp.z;\n" 13126 " gl_TessLevelOuter[1] = temp.w;\n" 13127 " gl_TessLevelOuter[2] = temp.x;\n" 13128 " gl_TessLevelOuter[3] = temp.y;\n" 13129 "}\n"; 13130 13131 return result_sstream.str(); 13132 } 13133 13134 /** Retrieves tess evaluation shader that should be used for the purpose of the test. 13135 * An overloaded version of a subroutine function is inserted if 13136 * @param include_duplicate_function flag is set to true. 13137 * 13138 * @param include_duplicate_function As per description. 13139 * 13140 * @return Requested string. 13141 **/ 13142 std::string NegativeTest10::getTessellationEvaluationShader(bool include_duplicate_function) 13143 { 13144 std::stringstream result_sstream; 13145 13146 result_sstream << "#version 400\n" 13147 "\n" 13148 "#extension GL_ARB_shader_subroutine : require\n" 13149 "\n" 13150 "layout (quads) in;\n" 13151 "\n" 13152 "subroutine void subroutineType(inout vec4 test);\n" 13153 "\n" 13154 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13155 "{\n" 13156 " test = vec4(2, 3, 4, 5);\n" 13157 "}\n" 13158 "\n" 13159 "subroutine uniform subroutineType function;\n" 13160 "\n"; 13161 13162 if (include_duplicate_function) 13163 { 13164 result_sstream << "void test_function(inout vec4 test)\n" 13165 "{\n" 13166 " test = vec4(3, 4, 5, 6);\n" 13167 "}\n" 13168 "\n"; 13169 } 13170 13171 result_sstream << "void main()\n" 13172 "{\n" 13173 " vec4 temp;\n" 13174 "\n" 13175 " function(temp);\n" 13176 "\n" 13177 " gl_Position = temp;\n" 13178 "}\n"; 13179 13180 return result_sstream.str(); 13181 } 13182 13183 /** Retrieves vertex shader that should be used for the purpose of the test. 13184 * An overloaded version of a subroutine function is inserted if 13185 * @param include_duplicate_function flag is set to true. 13186 * 13187 * @param include_duplicate_function As per description. 13188 * 13189 * @return Requested string. 13190 **/ 13191 std::string NegativeTest10::getVertexShader(bool include_duplicate_function) 13192 { 13193 std::stringstream result_sstream; 13194 13195 result_sstream << "#version 400\n" 13196 "\n" 13197 "#extension GL_ARB_shader_subroutine : require\n" 13198 "\n" 13199 "subroutine void subroutineType(inout vec4 test);\n" 13200 "\n" 13201 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13202 "{\n" 13203 " test = vec4(2, 3, 4, 5);\n" 13204 "}\n" 13205 "\n" 13206 "subroutine uniform subroutineType function;\n" 13207 "\n"; 13208 13209 if (include_duplicate_function) 13210 { 13211 result_sstream << "void test_function(inout vec4 test)\n" 13212 "{\n" 13213 " test = vec4(3, 4, 5, 6);\n" 13214 "}\n" 13215 "\n"; 13216 } 13217 13218 result_sstream << "void main()\n" 13219 "{\n" 13220 " function(gl_Position);\n" 13221 "}\n"; 13222 13223 return result_sstream.str(); 13224 } 13225 13226 /** Fills m_test_cases field with test case descriptors */ 13227 void NegativeTest10::initTestCases() 13228 { 13229 /* For each test case, only one shader stage should define a function that 13230 * has already been defined as a subroutine. */ 13231 for (int offending_shader_stage_it = static_cast<int>(Utils::SHADER_STAGE_FIRST); 13232 offending_shader_stage_it != static_cast<int>(Utils::SHADER_STAGE_COUNT); ++offending_shader_stage_it) 13233 { 13234 Utils::_shader_stage offending_shader_stage = static_cast<Utils::_shader_stage>(offending_shader_stage_it); 13235 /* Form the test case descriptor */ 13236 std::stringstream name_sstream; 13237 _test_case test_case; 13238 13239 name_sstream << "Broken shader stage:" << Utils::getShaderStageString(offending_shader_stage); 13240 13241 test_case.fs_body = getFragmentShader(offending_shader_stage == Utils::SHADER_STAGE_FRAGMENT); 13242 test_case.gs_body = getGeometryShader(offending_shader_stage == Utils::SHADER_STAGE_GEOMETRY); 13243 test_case.name = name_sstream.str(); 13244 test_case.tc_body = 13245 getTessellationControlShader(offending_shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); 13246 test_case.te_body = 13247 getTessellationEvaluationShader(offending_shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); 13248 test_case.vs_body = getVertexShader(offending_shader_stage == Utils::SHADER_STAGE_VERTEX); 13249 13250 m_test_cases.push_back(test_case); 13251 } 13252 } 13253 13254 /** Executes test iteration. 13255 * 13256 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 13257 */ 13258 tcu::TestNode::IterateResult NegativeTest10::iterate() 13259 { 13260 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 13261 13262 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 13263 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 13264 { 13265 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 13266 } 13267 13268 /* Form test cases */ 13269 initTestCases(); 13270 13271 /* Iterate over all test cases */ 13272 for (_test_cases_const_iterator test_case_iterator = m_test_cases.begin(); test_case_iterator != m_test_cases.end(); 13273 ++test_case_iterator) 13274 { 13275 const _test_case& test_case = *test_case_iterator; 13276 13277 /* Try to build the program object */ 13278 if (ShaderSubroutine::Utils::buildProgram(gl, test_case.vs_body, test_case.tc_body, test_case.te_body, 13279 test_case.gs_body, test_case.fs_body, DE_NULL, /* xfb_varyings */ 13280 0, /* n_xfb_varyings */ 13281 &m_vs_id, (test_case.tc_body.length() > 0) ? &m_tc_id : DE_NULL, 13282 (test_case.te_body.length() > 0) ? &m_te_id : DE_NULL, 13283 (test_case.gs_body.length() > 0) ? &m_gs_id : DE_NULL, 13284 (test_case.fs_body.length() > 0) ? &m_fs_id : DE_NULL, &m_po_id)) 13285 { 13286 m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" 13287 << test_case.name << "] test case, even though it was invalid." 13288 << tcu::TestLog::EndMessage; 13289 13290 m_has_test_passed = false; 13291 } 13292 13293 /* Delete any objects that may have been created */ 13294 deinit(); 13295 } /* for (all test cases) */ 13296 13297 /** All done */ 13298 if (m_has_test_passed) 13299 { 13300 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 13301 } 13302 else 13303 { 13304 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 13305 } 13306 13307 return STOP; 13308 } 13309 13310 /** Constructor. 13311 * 13312 * @param context Rendering context. 13313 **/ 13314 NegativeTest11::NegativeTest11(deqp::Context& context) 13315 : TestCase(context, "subroutine_uniforms_used_for_sampling_atomic_image_functions", 13316 "Tries to use subroutine uniforms in invalid way in sampling, " 13317 "atomic and image functions. Verifies that compile- or link-time " 13318 "error occurs.") 13319 , m_has_test_passed(true) 13320 , m_po_id(0) 13321 , m_vs_id(0) 13322 { 13323 /* Left blank intentionally */ 13324 } 13325 13326 /** Deinitializes any GL objects that may have been created during 13327 * test execution. 13328 **/ 13329 void NegativeTest11::deinit() 13330 { 13331 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 13332 13333 if (m_po_id != 0) 13334 { 13335 gl.deleteProgram(m_po_id); 13336 13337 m_po_id = 0; 13338 } 13339 13340 if (m_vs_id != 0) 13341 { 13342 gl.deleteShader(m_vs_id); 13343 13344 m_vs_id = 0; 13345 } 13346 } 13347 13348 /** Returns a literal corresponding to user-specified test case enum. 13349 * 13350 * @param test_case As per description. 13351 * 13352 * @return Requested string. 13353 **/ 13354 std::string NegativeTest11::getTestCaseString(const _test_case& test_case) 13355 { 13356 std::string result = "?"; 13357 13358 switch (test_case) 13359 { 13360 case TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT: 13361 result = "TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT"; 13362 break; 13363 case TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT: 13364 result = "TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT"; 13365 break; 13366 case TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT: 13367 result = "TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT"; 13368 break; 13369 default: 13370 break; 13371 } 13372 13373 return result; 13374 } 13375 13376 /** Retrieves vertex shader body for user-specified test case. 13377 * 13378 * @param test_case As per description. 13379 * 13380 * @return Requested string. 13381 **/ 13382 std::string NegativeTest11::getVertexShader(const _test_case& test_case) 13383 { 13384 std::stringstream result_sstream; 13385 13386 /* Form pre-amble */ 13387 result_sstream << "#version 400\n" 13388 "\n" 13389 "#extension GL_ARB_shader_subroutine : require\n"; 13390 13391 if (test_case == TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT) 13392 { 13393 result_sstream << "#extension GL_ARB_shader_atomic_counters : require\n"; 13394 } 13395 13396 result_sstream << "\n" 13397 /* Define a subroutine */ 13398 "subroutine void subroutineType(inout vec4 test);\n" 13399 "\n" 13400 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13401 "{\n" 13402 " test += vec4(0, 1, 2, 3);\n" 13403 "}\n" 13404 "\n" 13405 "subroutine uniform subroutineType function;\n" 13406 "\n" 13407 13408 /* Define main() body */ 13409 "void main()\n" 13410 "{\n"; 13411 13412 /* Implement case-specific behavior */ 13413 switch (test_case) 13414 { 13415 case TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT: 13416 { 13417 result_sstream << "if (atomicCounter(function) > 2)\n" 13418 "{\n" 13419 " gl_Position = vec4(1);\n" 13420 "}\n"; 13421 13422 break; 13423 } 13424 13425 case TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT: 13426 { 13427 result_sstream << "imageStore(function, vec2(0.0, 1.0), vec4(1.0) );\n"; 13428 13429 break; 13430 } 13431 13432 case TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT: 13433 { 13434 result_sstream << "gl_Position = texture(function, vec2(1.0) );\n"; 13435 13436 break; 13437 } 13438 13439 default: 13440 break; 13441 } /* switch (test_case) */ 13442 13443 /* Close main() body */ 13444 result_sstream << "}\n"; 13445 13446 /* Done */ 13447 return result_sstream.str(); 13448 } 13449 13450 /** Executes test iteration. 13451 * 13452 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 13453 */ 13454 tcu::TestNode::IterateResult NegativeTest11::iterate() 13455 { 13456 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 13457 13458 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 13459 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 13460 { 13461 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 13462 } 13463 13464 /* Iterate over all test cases */ 13465 for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) 13466 { 13467 if (static_cast<_test_case>(test_case) == TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT && 13468 !m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_atomic_counters")) 13469 { 13470 /* This iteration requires atomic counter support that this GL implementation 13471 * is not capable of. Skip the iteration 13472 */ 13473 continue; 13474 } 13475 13476 /* Try to build a program object using invalid vertex shader, specific to the 13477 * iteration we're currently in */ 13478 std::string vs_body = getVertexShader(static_cast<_test_case>(test_case)); 13479 13480 if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "", /* tc_body */ 13481 "", /* te_body */ 13482 "", /* gs_body */ 13483 "", /* fs_body */ 13484 DE_NULL, /* xfb_varyings */ 13485 0, /* n_xfb_varyings */ 13486 &m_vs_id, DE_NULL, /* out_tc_id */ 13487 DE_NULL, /* out_te_id */ 13488 DE_NULL, /* out_gs_id */ 13489 DE_NULL, /* out_fs_id */ 13490 &m_po_id)) 13491 { 13492 m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" 13493 << getTestCaseString(static_cast<_test_case>(test_case)) 13494 << "] test case, even though it was invalid." << tcu::TestLog::EndMessage; 13495 13496 m_has_test_passed = false; 13497 } 13498 13499 /* Delete any objects that may have been created */ 13500 deinit(); 13501 } /* for (all test cases) */ 13502 13503 /** All done */ 13504 if (m_has_test_passed) 13505 { 13506 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 13507 } 13508 else 13509 { 13510 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 13511 } 13512 13513 return STOP; 13514 } 13515 13516 /** Constructor. 13517 * 13518 * @param context Rendering context. 13519 **/ 13520 NegativeTest12::NegativeTest12(deqp::Context& context) 13521 : TestCase(context, "subroutines_not_allowed_as_variables_constructors_and_argument_or_return_types", 13522 "Verifies that it is not allowed to use subroutine type for " 13523 "local/global variables, constructors or argument/return type.") 13524 , m_has_test_passed(true) 13525 , m_po_id(0) 13526 , m_vs_id(0) 13527 { 13528 /* Left blank intentionally */ 13529 } 13530 13531 /** Deinitializes any GL objects that may have been created during 13532 * test execution. 13533 **/ 13534 void NegativeTest12::deinit() 13535 { 13536 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 13537 13538 if (m_po_id != 0) 13539 { 13540 gl.deleteProgram(m_po_id); 13541 13542 m_po_id = 0; 13543 } 13544 13545 if (m_vs_id != 0) 13546 { 13547 gl.deleteShader(m_vs_id); 13548 13549 m_vs_id = 0; 13550 } 13551 } 13552 13553 /** Returns a literal corresponding to user-specified test case enum. 13554 * 13555 * @param test_case As per description. 13556 * 13557 * @return Requested string. 13558 **/ 13559 std::string NegativeTest12::getTestCaseString(const _test_case& test_case) 13560 { 13561 std::string result = "?"; 13562 13563 switch (test_case) 13564 { 13565 case TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE: 13566 result = "TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE"; 13567 break; 13568 case TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE: 13569 result = "TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE"; 13570 break; 13571 case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR: 13572 result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR"; 13573 break; 13574 case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT: 13575 result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT"; 13576 break; 13577 case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE: 13578 result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE"; 13579 break; 13580 default: 13581 break; 13582 } 13583 13584 return result; 13585 } 13586 13587 /** Retrieves vertex shader body for user-specified test case. 13588 * 13589 * @param test_case As per description. 13590 * 13591 * @return Requested string. 13592 **/ 13593 std::string NegativeTest12::getVertexShader(const _test_case& test_case) 13594 { 13595 std::stringstream result_sstream; 13596 13597 /* Form pre-amble */ 13598 result_sstream << "#version 400\n" 13599 "\n" 13600 "#extension GL_ARB_shader_subroutine : require\n" 13601 "\n" 13602 /* Define a subroutine */ 13603 "subroutine void subroutineType(inout vec4 test);\n" 13604 "\n" 13605 "subroutine(subroutineType) void test_function(inout vec4 test)\n" 13606 "{\n" 13607 " test += vec4(0, 1, 2, 3);\n" 13608 "}\n" 13609 "\n" 13610 "subroutine uniform subroutineType function;\n" 13611 "\n"; 13612 13613 /* Include case-specific implementation */ 13614 switch (test_case) 13615 { 13616 case TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE: 13617 { 13618 result_sstream << "void main()\n" 13619 "{\n" 13620 " subroutine subroutineType function2;\n" 13621 " vec4 result;\n" 13622 "\n" 13623 " function2(result);\n" 13624 " gl_Position = result;\n" 13625 "}\n"; 13626 13627 break; 13628 } 13629 13630 case TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE: 13631 { 13632 result_sstream << "subroutine subroutineType function2;\n" 13633 "\n" 13634 "void main()\n" 13635 "{\n" 13636 " vec4 result;\n" 13637 "\n" 13638 " function2(result);\n" 13639 " gl_Position = result;\n" 13640 "}\n"; 13641 13642 break; 13643 } 13644 13645 case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR: 13646 { 13647 result_sstream << "void main()\n" 13648 "{\n" 13649 " subroutineType(function);\n" 13650 "}\n"; 13651 13652 break; 13653 } 13654 13655 case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT: 13656 { 13657 result_sstream << "vec4 test_function(subroutineType argument)\n" 13658 "{\n" 13659 " vec4 result = vec4(1, 2, 3, 4);\n" 13660 "\n" 13661 " argument(result);\n" 13662 "\n" 13663 " return result;\n" 13664 "}\n" 13665 "\n" 13666 "void main()\n" 13667 "{\n" 13668 " test_function(function);\n" 13669 "}\n"; 13670 13671 break; 13672 } 13673 13674 case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE: 13675 { 13676 result_sstream << "subroutineType test_function()\n" 13677 "{\n" 13678 " return function;\n" 13679 "}\n" 13680 "\n" 13681 "void main()\n" 13682 "{\n" 13683 " test_function()(gl_Position);\n" 13684 "}\n"; 13685 13686 break; 13687 } 13688 13689 default: 13690 break; 13691 } /* switch (test_case) */ 13692 13693 /* Done */ 13694 return result_sstream.str(); 13695 } 13696 13697 /** Executes test iteration. 13698 * 13699 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 13700 */ 13701 tcu::TestNode::IterateResult NegativeTest12::iterate() 13702 { 13703 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 13704 13705 /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ 13706 if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) 13707 { 13708 throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); 13709 } 13710 13711 /* Iterate over all test cases */ 13712 for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) 13713 { 13714 /* Try to build a program object using invalid vertex shader, specific to the 13715 * iteration we're currently in */ 13716 std::string vs_body = getVertexShader(static_cast<_test_case>(test_case)); 13717 13718 if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "", /* tc_body */ 13719 "", /* te_body */ 13720 "", /* gs_body */ 13721 "", /* fs_body */ 13722 DE_NULL, /* xfb_varyings */ 13723 0, /* n_xfb_varyings */ 13724 &m_vs_id, DE_NULL, /* out_tc_id */ 13725 DE_NULL, /* out_te_id */ 13726 DE_NULL, /* out_gs_id */ 13727 DE_NULL, /* out_fs_id */ 13728 &m_po_id)) 13729 { 13730 m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" 13731 << getTestCaseString(static_cast<_test_case>(test_case)) 13732 << "] test case, even though it was invalid." << tcu::TestLog::EndMessage; 13733 13734 m_has_test_passed = false; 13735 } 13736 13737 /* Delete any objects that may have been created */ 13738 deinit(); 13739 } /* for (all test cases) */ 13740 13741 /** All done */ 13742 if (m_has_test_passed) 13743 { 13744 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 13745 } 13746 else 13747 { 13748 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 13749 } 13750 13751 return STOP; 13752 } 13753 13754 } /* ShaderSubroutine */ 13755 13756 /** Constructor. 13757 * 13758 * @param context Rendering context. 13759 **/ 13760 ShaderSubroutineTests::ShaderSubroutineTests(deqp::Context& context) 13761 : TestCaseGroup(context, "shader_subroutine", "Verifies \"shader_subroutine\" functionality") 13762 { 13763 /* Left blank on purpose */ 13764 } 13765 13766 /** Initializes a texture_storage_multisample test group. 13767 * 13768 **/ 13769 void ShaderSubroutineTests::init(void) 13770 { 13771 addChild(new ShaderSubroutine::APITest1(m_context)); 13772 addChild(new ShaderSubroutine::APITest2(m_context)); 13773 addChild(new ShaderSubroutine::FunctionalTest1_2(m_context)); 13774 addChild(new ShaderSubroutine::FunctionalTest3_4(m_context)); 13775 addChild(new ShaderSubroutine::FunctionalTest5(m_context)); 13776 addChild(new ShaderSubroutine::FunctionalTest6(m_context)); 13777 addChild(new ShaderSubroutine::FunctionalTest7_8(m_context)); 13778 addChild(new ShaderSubroutine::FunctionalTest9(m_context)); 13779 addChild(new ShaderSubroutine::FunctionalTest10(m_context)); 13780 addChild(new ShaderSubroutine::FunctionalTest11(m_context)); 13781 addChild(new ShaderSubroutine::FunctionalTest12(m_context)); 13782 addChild(new ShaderSubroutine::FunctionalTest13(m_context)); 13783 addChild(new ShaderSubroutine::FunctionalTest14_15(m_context)); 13784 addChild(new ShaderSubroutine::FunctionalTest16(m_context)); 13785 addChild(new ShaderSubroutine::FunctionalTest17(m_context)); 13786 addChild(new ShaderSubroutine::FunctionalTest18_19(m_context)); 13787 addChild(new ShaderSubroutine::NegativeTest1(m_context)); 13788 addChild(new ShaderSubroutine::NegativeTest2(m_context)); 13789 addChild(new ShaderSubroutine::NegativeTest3(m_context)); 13790 addChild(new ShaderSubroutine::NegativeTest4(m_context)); 13791 addChild(new ShaderSubroutine::NegativeTest5(m_context)); 13792 addChild(new ShaderSubroutine::NegativeTest6(m_context)); 13793 addChild(new ShaderSubroutine::NegativeTest7(m_context)); 13794 addChild(new ShaderSubroutine::NegativeTest8(m_context)); 13795 addChild(new ShaderSubroutine::NegativeTest9(m_context)); 13796 addChild(new ShaderSubroutine::NegativeTest10(m_context)); 13797 addChild(new ShaderSubroutine::NegativeTest11(m_context)); 13798 addChild(new ShaderSubroutine::NegativeTest12(m_context)); 13799 } 13800 13801 } /* glcts namespace */ 13802
