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 gl4cShadingLanguage420PackTests.cpp 26 * \brief Implements conformance tests for "Shading Language 420Pack" functionality. 27 */ /*-------------------------------------------------------------------*/ 28 29 #include "gl4cShadingLanguage420PackTests.hpp" 30 31 #include "gluContextInfo.hpp" 32 #include "gluDefs.hpp" 33 #include "glwEnums.hpp" 34 #include "glwFunctions.hpp" 35 #include "tcuTestLog.hpp" 36 37 #include <algorithm> 38 #include <iomanip> 39 #include <stdio.h> 40 #include <string.h> 41 #include <string> 42 #include <vector> 43 44 #define IS_DEBUG 0 45 46 using namespace glw; 47 48 namespace gl4cts 49 { 50 51 namespace GLSL420Pack 52 { 53 /** Check binding of uniform 54 * 55 * @param program Program object 56 * @param name Array name 57 * @param expected_binding Expected binding value 58 * 59 * @return true if binding is as expected, false otherwise 60 **/ 61 bool Utils::checkUniformBinding(Utils::program& program, const glw::GLchar* name, glw::GLint expected_binding) 62 { 63 const GLint uniform_location = program.getUniformLocation(name); 64 if (-1 == uniform_location) 65 { 66 TCU_FAIL("Uniform is inactive"); 67 } 68 69 GLint binding = program.getUniform1i(uniform_location); 70 71 return (expected_binding == binding); 72 } 73 /** Check binding of uniform array element at <index> 74 * 75 * @param program Program object 76 * @param name Array name 77 * @param index Index 78 * @param expected_binding Expected binding value 79 * 80 * @return true if binding is as expected, false otherwise 81 **/ 82 bool Utils::checkUniformArrayBinding(Utils::program& program, const glw::GLchar* name, glw::GLuint index, 83 glw::GLint expected_binding) 84 { 85 GLchar buffer[64]; 86 sprintf(buffer, "%s[%d]", name, index); 87 88 const GLint uniform_location = program.getUniformLocation(buffer); 89 if (-1 == uniform_location) 90 { 91 TCU_FAIL("Uniform is inactive"); 92 } 93 94 GLint binding = program.getUniform1i(uniform_location); 95 96 return (expected_binding == binding); 97 } 98 99 /** Check if given qualifier is present in set 100 * 101 * @param qualifier Specific qualifier 102 * @param qualifiers Qualifiers' set 103 * 104 * @return true if qualifier is present, false otherwise 105 **/ 106 bool Utils::doesContainQualifier(Utils::QUALIFIERS qualifier, const Utils::qualifierSet& qualifiers) 107 { 108 for (GLuint i = 0; i < qualifiers.size(); ++i) 109 { 110 if (qualifiers[i] == qualifier) 111 { 112 return true; 113 } 114 } 115 116 return false; 117 } 118 119 /** Check if given stage supports specific qualifier 120 * 121 * @param stage Shader stage 122 * @param storage Storage of variable 123 * @param qualifier Qualifier 124 * 125 * @return true if qualifier can be used in given stage, false otherwise 126 **/ 127 bool Utils::doesStageSupportQualifier(Utils::SHADER_STAGES stage, Utils::VARIABLE_STORAGE storage, 128 Utils::QUALIFIERS qualifier) 129 { 130 bool result = true; 131 132 switch (stage) 133 { 134 case COMPUTE_SHADER: 135 switch (qualifier) 136 { 137 case QUAL_NONE: 138 case QUAL_UNIFORM: 139 case QUAL_LOWP: 140 case QUAL_MEDIUMP: 141 case QUAL_HIGHP: 142 case QUAL_INVARIANT: 143 result = true; 144 break; 145 default: 146 result = false; 147 break; 148 } 149 break; 150 case FRAGMENT_SHADER: 151 if (QUAL_PATCH == qualifier) 152 { 153 result = false; 154 } 155 else if ((OUTPUT == storage) && 156 ((QUAL_SMOOTH == qualifier) || (QUAL_NOPERSPECTIVE == qualifier) || (QUAL_FLAT == qualifier))) 157 { 158 result = false; 159 } 160 break; 161 case VERTEX_SHADER: 162 if (QUAL_PATCH == qualifier) 163 { 164 result = false; 165 } 166 else if ((INPUT == storage) && 167 ((QUAL_SMOOTH == qualifier) || (QUAL_NOPERSPECTIVE == qualifier) || (QUAL_FLAT == qualifier) || 168 (QUAL_INVARIANT == qualifier) || (QUAL_CENTROID == qualifier) || (QUAL_SAMPLE == qualifier))) 169 { 170 result = false; 171 } 172 break; 173 case GEOMETRY_SHADER: 174 if (QUAL_PATCH == qualifier) 175 { 176 result = false; 177 } 178 break; 179 case TESS_CTRL_SHADER: 180 if ((INPUT == storage) && (QUAL_PATCH == qualifier)) 181 { 182 result = false; 183 } 184 break; 185 case TESS_EVAL_SHADER: 186 if ((OUTPUT == storage) && (QUAL_PATCH == qualifier)) 187 { 188 result = false; 189 } 190 break; 191 default: 192 break; 193 } 194 195 return result; 196 } 197 198 /** Get string for qualifier 199 * 200 * @param qualifier Qualifier 201 * 202 * @return A string for given qualifier 203 **/ 204 const GLchar* Utils::getQualifierString(Utils::QUALIFIERS qualifier) 205 { 206 const GLchar* result = 0; 207 switch (qualifier) 208 { 209 case QUAL_NONE: 210 result = ""; 211 break; 212 case QUAL_CONST: 213 result = "const"; 214 break; 215 case QUAL_IN: 216 result = "in"; 217 break; 218 case QUAL_OUT: 219 result = "out"; 220 break; 221 case QUAL_INOUT: 222 result = "inout"; 223 break; 224 case QUAL_UNIFORM: 225 result = "uniform"; 226 break; 227 case QUAL_PATCH: 228 result = "patch"; 229 break; 230 case QUAL_CENTROID: 231 result = "centroid"; 232 break; 233 case QUAL_SAMPLE: 234 result = "sample"; 235 break; 236 case QUAL_FLAT: 237 result = "flat"; 238 break; 239 case QUAL_NOPERSPECTIVE: 240 result = "noperspective"; 241 break; 242 case QUAL_SMOOTH: 243 result = "smooth"; 244 break; 245 case QUAL_LOCATION: 246 result = "layout (location = LOC_VALUE)"; 247 break; 248 case QUAL_LOWP: 249 result = "lowp"; 250 break; 251 case QUAL_MEDIUMP: 252 result = "mediump"; 253 break; 254 case QUAL_HIGHP: 255 result = "highp"; 256 break; 257 case QUAL_PRECISE: 258 result = "precise"; 259 break; 260 case QUAL_INVARIANT: 261 result = "invariant"; 262 break; 263 default: 264 TCU_FAIL("Invalid enum"); 265 }; 266 267 return result; 268 } 269 270 /** Returns a string with set of qualifiers. 271 * 272 * @param qualifiers Set of qualifiers 273 * 274 * @return String 275 **/ 276 std::string Utils::getQualifiersListString(const qualifierSet& qualifiers) 277 { 278 static const GLchar* qualifier_list = "QUALIFIER QUALIFIER_LIST"; 279 const GLuint qualifier_list_length = static_cast<GLuint>(strlen(qualifier_list)); 280 281 /* Tokens */ 282 static const GLchar* token_qualifier = "QUALIFIER"; 283 static const GLchar* token_qual_list = "QUALIFIER_LIST"; 284 285 /* Variables */ 286 std::string list = token_qual_list; 287 size_t position = 0; 288 289 /* Replace tokens */ 290 for (GLuint i = 0; i < qualifiers.size(); ++i) 291 { 292 Utils::replaceToken(token_qual_list, position, qualifier_list, list); 293 position -= qualifier_list_length; 294 295 const GLchar* qualifier_str = getQualifierString(qualifiers[i]); 296 297 Utils::replaceToken(token_qualifier, position, qualifier_str, list); 298 } 299 300 Utils::replaceToken(token_qual_list, position, "", list); 301 302 return list; 303 } 304 305 /** Prepare a set of qualifiers for given shader stage and variable storage. 306 * Filters out not supported qualifiers from in_qualifiers 307 * 308 * @param in_qualifiers Origiranl set of qualifiers 309 * @param stage Shader stage 310 * @param storage Variable storage 311 * 312 * @return Set of qualifiers 313 **/ 314 Utils::qualifierSet Utils::prepareQualifiersSet(const qualifierSet& in_qualifiers, SHADER_STAGES stage, 315 VARIABLE_STORAGE storage) 316 { 317 qualifierSet result; 318 319 for (GLuint i = 0; i < in_qualifiers.size(); ++i) 320 { 321 Utils::QUALIFIERS qualifier = in_qualifiers[i]; 322 323 if (false == doesStageSupportQualifier(stage, storage, qualifier)) 324 { 325 continue; 326 }; 327 328 /* Replace wrong storage qualifiers */ 329 if ((Utils::INPUT == storage) && ((Utils::QUAL_UNIFORM == qualifier) || (Utils::QUAL_OUT == qualifier))) 330 { 331 qualifier = QUAL_IN; 332 } 333 else if ((Utils::OUTPUT == storage) && ((Utils::QUAL_IN == qualifier) || (Utils::QUAL_UNIFORM == qualifier))) 334 { 335 qualifier = QUAL_OUT; 336 } 337 else if ((Utils::UNIFORM == storage) && ((Utils::QUAL_IN == qualifier) || (Utils::QUAL_OUT == qualifier))) 338 { 339 qualifier = QUAL_UNIFORM; 340 } 341 342 result.push_back(qualifier); 343 } 344 345 return result; 346 } 347 348 /** Get image type for given texture type 349 * 350 * @param type Texture type 351 * 352 * @return String representing sampler type 353 **/ 354 const GLchar* Utils::getImageType(Utils::TEXTURE_TYPES type) 355 { 356 const GLchar* result = 0; 357 358 switch (type) 359 { 360 case TEX_BUFFER: 361 result = "imageBuffer"; 362 break; 363 case TEX_2D: 364 result = "image2D"; 365 break; 366 case TEX_2D_RECT: 367 result = "image2DRect"; 368 break; 369 case TEX_2D_ARRAY: 370 result = "image2DArray"; 371 break; 372 case TEX_3D: 373 result = "image3D"; 374 break; 375 case TEX_CUBE: 376 result = "imageCube"; 377 break; 378 case TEX_1D: 379 result = "image1D"; 380 break; 381 case TEX_1D_ARRAY: 382 result = "image1DArray"; 383 break; 384 default: 385 TCU_FAIL("Invalid enum"); 386 } 387 388 return result; 389 } 390 391 /** Get number of coordinates required to address texture of given type 392 * 393 * @param type Type of texture 394 * 395 * @return Number of coordinates 396 **/ 397 GLuint Utils::getNumberOfCoordinates(Utils::TEXTURE_TYPES type) 398 { 399 GLuint result = 0; 400 401 switch (type) 402 { 403 case TEX_BUFFER: 404 result = 1; 405 break; 406 case TEX_2D: 407 result = 2; 408 break; 409 case TEX_2D_RECT: 410 result = 2; 411 break; 412 case TEX_2D_ARRAY: 413 result = 3; 414 break; 415 case TEX_3D: 416 result = 3; 417 break; 418 case TEX_CUBE: 419 result = 3; 420 break; 421 case TEX_1D: 422 result = 1; 423 break; 424 case TEX_1D_ARRAY: 425 result = 2; 426 break; 427 default: 428 TCU_FAIL("Invalid enum"); 429 } 430 431 return result; 432 } 433 434 /** Get sampler type for given texture type 435 * 436 * @param type Texture type 437 * 438 * @return String representing sampler type 439 **/ 440 const GLchar* Utils::getSamplerType(Utils::TEXTURE_TYPES type) 441 { 442 const GLchar* result = 0; 443 444 switch (type) 445 { 446 case TEX_BUFFER: 447 result = "samplerBuffer"; 448 break; 449 case TEX_2D: 450 result = "sampler2D"; 451 break; 452 case TEX_2D_RECT: 453 result = "sampler2DRect"; 454 break; 455 case TEX_2D_ARRAY: 456 result = "sampler2DArray"; 457 break; 458 case TEX_3D: 459 result = "sampler3D"; 460 break; 461 case TEX_CUBE: 462 result = "samplerCube"; 463 break; 464 case TEX_1D: 465 result = "sampler1D"; 466 break; 467 case TEX_1D_ARRAY: 468 result = "sampler1DArray"; 469 break; 470 default: 471 TCU_FAIL("Invalid enum"); 472 } 473 474 return result; 475 } 476 477 /** Get target for given texture type 478 * 479 * @param type Type of texture 480 * 481 * @return Target 482 **/ 483 GLenum Utils::getTextureTartet(Utils::TEXTURE_TYPES type) 484 { 485 GLenum result = 0; 486 487 switch (type) 488 { 489 case TEX_BUFFER: 490 result = GL_TEXTURE_BUFFER; 491 break; 492 case TEX_2D: 493 result = GL_TEXTURE_2D; 494 break; 495 case TEX_2D_RECT: 496 result = GL_TEXTURE_RECTANGLE; 497 break; 498 case TEX_2D_ARRAY: 499 result = GL_TEXTURE_2D_ARRAY; 500 break; 501 case TEX_3D: 502 result = GL_TEXTURE_3D; 503 break; 504 case TEX_CUBE: 505 result = GL_TEXTURE_CUBE_MAP; 506 break; 507 case TEX_1D: 508 result = GL_TEXTURE_1D; 509 break; 510 case TEX_1D_ARRAY: 511 result = GL_TEXTURE_1D_ARRAY; 512 break; 513 default: 514 TCU_FAIL("Invalid enum"); 515 } 516 517 return result; 518 } 519 520 /** Get name of given texture type 521 * 522 * @param type Texture type 523 * 524 * @return String representing name of texture type 525 **/ 526 const GLchar* Utils::getTextureTypeName(Utils::TEXTURE_TYPES type) 527 { 528 const GLchar* result = 0; 529 530 switch (type) 531 { 532 case TEX_BUFFER: 533 result = "buffer"; 534 break; 535 case TEX_2D: 536 result = "2D"; 537 break; 538 case TEX_2D_RECT: 539 result = "2D rectangle"; 540 break; 541 case TEX_2D_ARRAY: 542 result = "2D array"; 543 break; 544 case TEX_3D: 545 result = "3D"; 546 break; 547 case TEX_CUBE: 548 result = "cube"; 549 break; 550 case TEX_1D: 551 result = "1D"; 552 break; 553 case TEX_1D_ARRAY: 554 result = "1D array"; 555 break; 556 default: 557 TCU_FAIL("Invalid enum"); 558 } 559 560 return result; 561 } 562 563 /** Check if glsl support matrices for specific basic type 564 * 565 * @param type Basic type 566 * 567 * @return true if matrices of <type> are supported, false otherwise 568 **/ 569 bool Utils::doesTypeSupportMatrix(TYPES type) 570 { 571 bool result = false; 572 573 switch (type) 574 { 575 case FLOAT: 576 case DOUBLE: 577 result = true; 578 break; 579 case INT: 580 case UINT: 581 result = false; 582 break; 583 default: 584 TCU_FAIL("Invliad enum"); 585 } 586 587 return result; 588 } 589 590 /** Get string representing name of shader stage 591 * 592 * @param stage Shader stage 593 * 594 * @return String with name of shader stage 595 **/ 596 const glw::GLchar* Utils::getShaderStageName(Utils::SHADER_STAGES stage) 597 { 598 const GLchar* result = 0; 599 600 switch (stage) 601 { 602 case COMPUTE_SHADER: 603 result = "compute"; 604 break; 605 case VERTEX_SHADER: 606 result = "vertex"; 607 break; 608 case TESS_CTRL_SHADER: 609 result = "tesselation control"; 610 break; 611 case TESS_EVAL_SHADER: 612 result = "tesselation evaluation"; 613 break; 614 case GEOMETRY_SHADER: 615 result = "geomtery"; 616 break; 617 case FRAGMENT_SHADER: 618 result = "fragment"; 619 break; 620 default: 621 TCU_FAIL("Invalid enum"); 622 } 623 624 return result; 625 } 626 627 /** Get glsl name of specified type 628 * 629 * @param type Basic type 630 * @param n_columns Number of columns 631 * @param n_rows Number of rows 632 * 633 * @return Name of glsl type 634 **/ 635 const glw::GLchar* Utils::getTypeName(TYPES type, glw::GLuint n_columns, glw::GLuint n_rows) 636 { 637 static const GLchar* float_lut[4][4] = { 638 { "float", "vec2", "vec3", "vec4" }, 639 { 0, "mat2", "mat2x3", "mat2x4" }, 640 { 0, "mat3x2", "mat3", "mat3x4" }, 641 { 0, "mat4x2", "mat4x3", "mat4" }, 642 }; 643 644 static const GLchar* double_lut[4][4] = { 645 { "double", "dvec2", "dvec3", "dvec4" }, 646 { 0, "dmat2", "dmat2x3", "dmat2x4" }, 647 { 0, "dmat3x2", "dmat3", "dmat3x4" }, 648 { 0, "dmat4x2", "dmat4x3", "dmat4" }, 649 }; 650 651 static const GLchar* int_lut[4] = { "int", "ivec2", "ivec3", "ivec4" }; 652 653 static const GLchar* uint_lut[4] = { "uint", "uvec2", "uvec3", "uvec4" }; 654 655 const GLchar* result = 0; 656 657 if ((1 > n_columns) || (1 > n_rows) || (4 < n_columns) || (4 < n_rows)) 658 { 659 return 0; 660 } 661 662 switch (type) 663 { 664 case FLOAT: 665 result = float_lut[n_columns - 1][n_rows - 1]; 666 break; 667 case DOUBLE: 668 result = double_lut[n_columns - 1][n_rows - 1]; 669 break; 670 case INT: 671 result = int_lut[n_rows - 1]; 672 break; 673 case UINT: 674 result = uint_lut[n_rows - 1]; 675 break; 676 default: 677 TCU_FAIL("Invliad enum"); 678 } 679 680 return result; 681 } 682 683 /** Get proper glUniformNdv routine for vectors with specified number of rows 684 * 685 * @param gl GL functions 686 * @param n_rows Number of rows 687 * 688 * @return Function address 689 **/ 690 Utils::uniformNdv Utils::getUniformNdv(const glw::Functions& gl, glw::GLuint n_rows) 691 { 692 uniformNdv result = 0; 693 694 switch (n_rows) 695 { 696 case 1: 697 result = gl.uniform1dv; 698 break; 699 case 2: 700 result = gl.uniform2dv; 701 break; 702 case 3: 703 result = gl.uniform3dv; 704 break; 705 case 4: 706 result = gl.uniform4dv; 707 break; 708 default: 709 TCU_FAIL("Invalid number of rows"); 710 } 711 712 return result; 713 } 714 715 /** Get proper glUniformNfv routine for vectors with specified number of rows 716 * 717 * @param gl GL functions 718 * @param n_rows Number of rows 719 * 720 * @return Function address 721 **/ 722 Utils::uniformNfv Utils::getUniformNfv(const glw::Functions& gl, glw::GLuint n_rows) 723 { 724 uniformNfv result = 0; 725 726 switch (n_rows) 727 { 728 case 1: 729 result = gl.uniform1fv; 730 break; 731 case 2: 732 result = gl.uniform2fv; 733 break; 734 case 3: 735 result = gl.uniform3fv; 736 break; 737 case 4: 738 result = gl.uniform4fv; 739 break; 740 default: 741 TCU_FAIL("Invalid number of rows"); 742 } 743 744 return result; 745 } 746 747 /** Get proper glUniformNiv routine for vectors with specified number of rows 748 * 749 * @param gl GL functions 750 * @param n_rows Number of rows 751 * 752 * @return Function address 753 **/ 754 Utils::uniformNiv Utils::getUniformNiv(const glw::Functions& gl, glw::GLuint n_rows) 755 { 756 uniformNiv result = 0; 757 758 switch (n_rows) 759 { 760 case 1: 761 result = gl.uniform1iv; 762 break; 763 case 2: 764 result = gl.uniform2iv; 765 break; 766 case 3: 767 result = gl.uniform3iv; 768 break; 769 case 4: 770 result = gl.uniform4iv; 771 break; 772 default: 773 TCU_FAIL("Invalid number of rows"); 774 } 775 776 return result; 777 } 778 779 /** Get proper glUniformNuiv routine for vectors with specified number of rows 780 * 781 * @param gl GL functions 782 * @param n_rows Number of rows 783 * 784 * @return Function address 785 **/ 786 Utils::uniformNuiv Utils::getUniformNuiv(const glw::Functions& gl, glw::GLuint n_rows) 787 { 788 uniformNuiv result = 0; 789 790 switch (n_rows) 791 { 792 case 1: 793 result = gl.uniform1uiv; 794 break; 795 case 2: 796 result = gl.uniform2uiv; 797 break; 798 case 3: 799 result = gl.uniform3uiv; 800 break; 801 case 4: 802 result = gl.uniform4uiv; 803 break; 804 default: 805 TCU_FAIL("Invalid number of rows"); 806 } 807 808 return result; 809 } 810 811 /** Get proper glUniformMatrixNdv routine for matrix with specified number of columns and rows 812 * 813 * @param gl GL functions 814 * @param n_rows Number of rows 815 * 816 * @return Function address 817 **/ 818 Utils::uniformMatrixNdv Utils::getUniformMatrixNdv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows) 819 { 820 uniformMatrixNdv result = 0; 821 822 switch (n_columns) 823 { 824 case 2: 825 switch (n_rows) 826 { 827 case 2: 828 result = gl.uniformMatrix2dv; 829 break; 830 case 3: 831 result = gl.uniformMatrix2x3dv; 832 break; 833 case 4: 834 result = gl.uniformMatrix2x4dv; 835 break; 836 default: 837 TCU_FAIL("Invalid number of rows"); 838 } 839 break; 840 case 3: 841 switch (n_rows) 842 { 843 case 2: 844 result = gl.uniformMatrix3x2dv; 845 break; 846 case 3: 847 result = gl.uniformMatrix3dv; 848 break; 849 case 4: 850 result = gl.uniformMatrix3x4dv; 851 break; 852 default: 853 TCU_FAIL("Invalid number of rows"); 854 } 855 break; 856 case 4: 857 switch (n_rows) 858 { 859 case 2: 860 result = gl.uniformMatrix4x2dv; 861 break; 862 case 3: 863 result = gl.uniformMatrix4x3dv; 864 break; 865 case 4: 866 result = gl.uniformMatrix4dv; 867 break; 868 default: 869 TCU_FAIL("Invalid number of rows"); 870 } 871 break; 872 default: 873 TCU_FAIL("Invalid number of columns"); 874 } 875 876 return result; 877 } 878 879 /** Get proper glUniformMatrixNfv routine for vectors with specified number of columns and rows 880 * 881 * @param gl GL functions 882 * @param n_rows Number of rows 883 * 884 * @return Function address 885 **/ 886 Utils::uniformMatrixNfv Utils::getUniformMatrixNfv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows) 887 { 888 uniformMatrixNfv result = 0; 889 890 switch (n_columns) 891 { 892 case 2: 893 switch (n_rows) 894 { 895 case 2: 896 result = gl.uniformMatrix2fv; 897 break; 898 case 3: 899 result = gl.uniformMatrix2x3fv; 900 break; 901 case 4: 902 result = gl.uniformMatrix2x4fv; 903 break; 904 default: 905 TCU_FAIL("Invalid number of rows"); 906 } 907 break; 908 case 3: 909 switch (n_rows) 910 { 911 case 2: 912 result = gl.uniformMatrix3x2fv; 913 break; 914 case 3: 915 result = gl.uniformMatrix3fv; 916 break; 917 case 4: 918 result = gl.uniformMatrix3x4fv; 919 break; 920 default: 921 TCU_FAIL("Invalid number of rows"); 922 } 923 break; 924 case 4: 925 switch (n_rows) 926 { 927 case 2: 928 result = gl.uniformMatrix4x2fv; 929 break; 930 case 3: 931 result = gl.uniformMatrix4x3fv; 932 break; 933 case 4: 934 result = gl.uniformMatrix4fv; 935 break; 936 default: 937 TCU_FAIL("Invalid number of rows"); 938 } 939 break; 940 default: 941 TCU_FAIL("Invalid number of columns"); 942 } 943 944 return result; 945 } 946 947 /** Prepare definition of input or output block's variable 948 * 949 * @param qualifiers Set of qualifiers 950 * @param type_name Name of type 951 * @param variable_name Meaningful part of variable name, eg. tex_coord 952 * 953 * @return Definition of variable 954 **/ 955 std::string Utils::getBlockVariableDefinition(const qualifierSet& qualifiers, const glw::GLchar* type_name, 956 const glw::GLchar* variable_name) 957 { 958 /* Templates */ 959 static const GLchar* def_template = "QUALIFIER_LISTTYPE VARIABLE_NAME"; 960 961 /* Tokens */ 962 static const GLchar* token_type = "TYPE"; 963 static const GLchar* token_variable_name = "VARIABLE_NAME"; 964 static const GLchar* token_qual_list = "QUALIFIER_LIST"; 965 966 /* Variables */ 967 std::string variable_definition = def_template; 968 size_t position = 0; 969 970 /* Get qualifiers list */ 971 const std::string& list = getQualifiersListString(qualifiers); 972 973 /* Replace tokens */ 974 Utils::replaceToken(token_qual_list, position, list.c_str(), variable_definition); 975 Utils::replaceToken(token_type, position, type_name, variable_definition); 976 Utils::replaceToken(token_variable_name, position, variable_name, variable_definition); 977 978 /* Done */ 979 return variable_definition; 980 } 981 982 /** Prepare reference to input or output variable 983 * 984 * @param flavour "Flavour" of variable 985 * @param variable_name Meaningful part of variable name, eg. tex_coord 986 * @param block_name Name of block 987 * 988 * @return Reference to variable 989 **/ 990 std::string Utils::getBlockVariableReference(VARIABLE_FLAVOUR flavour, const glw::GLchar* variable_name, 991 const glw::GLchar* block_name) 992 { 993 /* Templates */ 994 static const GLchar* ref_template = "BLOCK_NAME.VARIABLE_NAME"; 995 static const GLchar* array_ref_template = "BLOCK_NAME[0].VARIABLE_NAME"; 996 static const GLchar* tcs_ref_template = "BLOCK_NAME[gl_InvocationID].VARIABLE_NAME"; 997 998 /* Token */ 999 static const GLchar* token_block_name = "BLOCK_NAME"; 1000 static const GLchar* token_variable_name = "VARIABLE_NAME"; 1001 1002 /* Variables */ 1003 std::string variable_definition; 1004 size_t position = 0; 1005 1006 /* Select variable reference template */ 1007 switch (flavour) 1008 { 1009 case BASIC: 1010 variable_definition = ref_template; 1011 break; 1012 case ARRAY: 1013 variable_definition = array_ref_template; 1014 break; 1015 case INDEXED_BY_INVOCATION_ID: 1016 variable_definition = tcs_ref_template; 1017 break; 1018 default: 1019 variable_definition = ref_template; 1020 break; 1021 } 1022 1023 /* Replace tokens */ 1024 replaceAllTokens(token_block_name, block_name, variable_definition); 1025 replaceToken(token_variable_name, position, variable_name, variable_definition); 1026 1027 /* Done */ 1028 return variable_definition; 1029 } 1030 1031 /** Prepare definition of input or output variable 1032 * 1033 * @param flavour "Flavour" of variable 1034 * @param qualifiers Set of qualifiers 1035 * @param type_name Name of type 1036 * @param variable_name Meaningful part of variable name, eg. tex_coord 1037 * 1038 * @return Definition of variable 1039 **/ 1040 std::string Utils::getVariableDefinition(VARIABLE_FLAVOUR flavour, const qualifierSet& qualifiers, 1041 const glw::GLchar* type_name, const glw::GLchar* variable_name) 1042 { 1043 /* Templates */ 1044 static const GLchar* def_template = "QUALIFIER_LISTTYPE VARIABLE_NAME"; 1045 static const GLchar* def_array_template = "QUALIFIER_LISTTYPE VARIABLE_NAME[]"; 1046 1047 /* Tokens */ 1048 static const GLchar* token_type = "TYPE"; 1049 static const GLchar* token_variable_name = "VARIABLE_NAME"; 1050 static const GLchar* token_qual_list = "QUALIFIER_LIST"; 1051 1052 /* Variables */ 1053 std::string variable_definition; 1054 size_t position = 0; 1055 1056 /* Select variable definition template */ 1057 switch (flavour) 1058 { 1059 case BASIC: 1060 variable_definition = def_template; 1061 break; 1062 case ARRAY: 1063 case INDEXED_BY_INVOCATION_ID: 1064 variable_definition = def_array_template; 1065 break; 1066 default: 1067 TCU_FAIL("Invliad enum"); 1068 break; 1069 } 1070 1071 /* Get qualifiers list */ 1072 const std::string& list = getQualifiersListString(qualifiers); 1073 1074 /* Replace tokens */ 1075 replaceToken(token_qual_list, position, list.c_str(), variable_definition); 1076 replaceToken(token_type, position, type_name, variable_definition); 1077 replaceToken(token_variable_name, position, variable_name, variable_definition); 1078 1079 /* Done */ 1080 return variable_definition; 1081 } 1082 1083 /** Get "flavour" of variable 1084 * 1085 * @param stage Shader stage 1086 * @param storage Storage of variable 1087 * @param qualifiers Set of qualifiers for variable 1088 * 1089 * @return "Flavour" of variable 1090 **/ 1091 Utils::VARIABLE_FLAVOUR Utils::getVariableFlavour(SHADER_STAGES stage, VARIABLE_STORAGE storage, 1092 const qualifierSet& qualifiers) 1093 { 1094 VARIABLE_FLAVOUR result; 1095 1096 if (UNIFORM == storage) 1097 { 1098 result = BASIC; 1099 } 1100 else 1101 { 1102 switch (stage) 1103 { 1104 case Utils::GEOMETRY_SHADER: 1105 if (Utils::INPUT == storage) 1106 { 1107 result = ARRAY; 1108 } 1109 else /* OUTPUT */ 1110 { 1111 result = BASIC; 1112 } 1113 break; 1114 case Utils::TESS_EVAL_SHADER: 1115 if ((false == Utils::doesContainQualifier(Utils::QUAL_PATCH, qualifiers)) && (Utils::INPUT == storage)) 1116 { 1117 result = ARRAY; 1118 } 1119 else /* OUTPUT */ 1120 { 1121 result = BASIC; 1122 } 1123 break; 1124 case Utils::TESS_CTRL_SHADER: 1125 if ((true == Utils::doesContainQualifier(Utils::QUAL_PATCH, qualifiers)) && (Utils::OUTPUT == storage)) 1126 { 1127 result = BASIC; 1128 } 1129 else 1130 { 1131 result = INDEXED_BY_INVOCATION_ID; 1132 } 1133 break; 1134 case Utils::VERTEX_SHADER: 1135 case Utils::FRAGMENT_SHADER: 1136 result = BASIC; 1137 break; 1138 default: 1139 TCU_FAIL("Invliad enum"); 1140 break; 1141 } 1142 } 1143 1144 return result; 1145 } 1146 1147 /** Prepare name of input or output variable 1148 * 1149 * @param stage Shader stage 1150 * @param storage Storage of variable 1151 * @param variable_name Meaningful part of variable name, eg. tex_coord 1152 * 1153 * @return Name of variable 1154 **/ 1155 std::string Utils::getVariableName(SHADER_STAGES stage, VARIABLE_STORAGE storage, const glw::GLchar* variable_name) 1156 { 1157 /* Variable name template */ 1158 static const GLchar* variable_name_template = "PRECEEDING_PREFIX_VARIABLE_NAME"; 1159 1160 /* Tokens */ 1161 static const GLchar* token_preceeding = "PRECEEDING"; 1162 static const GLchar* token_prefix = "PREFIX"; 1163 static const GLchar* token_variable_name = "VARIABLE_NAME"; 1164 1165 static const GLchar* prefixes[Utils::STORAGE_MAX][Utils::SHADER_STAGES_MAX][2] = { 1166 /* COMPUTE, VERTEX, TCS, TES, GEOMETRY, FRAGMENT */ 1167 { { "", "" }, 1168 { "in", "vs" }, 1169 { "vs", "tcs" }, 1170 { "tcs", "tes" }, 1171 { "tes", "gs" }, 1172 { "gs", "fs" } }, /* INPUT */ 1173 { { "", "" }, 1174 { "vs", "tcs" }, 1175 { "tcs", "tes" }, 1176 { "tes", "gs" }, 1177 { "gs", "fs" }, 1178 { "fs", "out" } }, /* OUTPUT */ 1179 { { "uni", "comp" }, 1180 { "uni", "vs" }, 1181 { "uni", "tcs" }, 1182 { "uni", "tes" }, 1183 { "uni", "gs" }, 1184 { "uni", "fs" } } /* UNIFORM */ 1185 }; 1186 1187 /* Variables */ 1188 const GLchar* preceeding = prefixes[storage][stage][0]; 1189 const GLchar* prefix = prefixes[storage][stage][1]; 1190 std::string name = variable_name_template; 1191 size_t position = 0; 1192 1193 /* Replace tokens */ 1194 Utils::replaceToken(token_preceeding, position, preceeding, name); 1195 Utils::replaceToken(token_prefix, position, prefix, name); 1196 Utils::replaceToken(token_variable_name, position, variable_name, name); 1197 1198 /* Done */ 1199 return name; 1200 } 1201 1202 /** Prepare reference to input or output variable 1203 * 1204 * @param flavour "Flavour" of variable 1205 * @param variable_name Meaningful part of variable name, eg. tex_coord 1206 * 1207 * @return Reference to variable 1208 **/ 1209 std::string Utils::getVariableReference(VARIABLE_FLAVOUR flavour, const glw::GLchar* variable_name) 1210 { 1211 /* Templates */ 1212 static const GLchar* ref_template = "VARIABLE_NAME"; 1213 static const GLchar* array_ref_template = "VARIABLE_NAME[0]"; 1214 static const GLchar* tcs_ref_template = "VARIABLE_NAME[gl_InvocationID]"; 1215 1216 /* Token */ 1217 static const GLchar* token_variable_name = "VARIABLE_NAME"; 1218 1219 /* Variables */ 1220 std::string variable_definition; 1221 size_t position = 0; 1222 1223 /* Select variable reference template */ 1224 switch (flavour) 1225 { 1226 case BASIC: 1227 variable_definition = ref_template; 1228 break; 1229 case ARRAY: 1230 variable_definition = array_ref_template; 1231 break; 1232 case INDEXED_BY_INVOCATION_ID: 1233 variable_definition = tcs_ref_template; 1234 break; 1235 default: 1236 variable_definition = ref_template; 1237 break; 1238 } 1239 1240 /* Replace token */ 1241 Utils::replaceToken(token_variable_name, position, variable_name, variable_definition); 1242 1243 /* Done */ 1244 return variable_definition; 1245 } 1246 1247 /** Prepare definition and reference string for block varaible 1248 * 1249 * @param in_stage Shader stage 1250 * @param in_storage Storage of variable 1251 * @param in_qualifiers Set of qualifiers 1252 * @param in_type_name Type name 1253 * @param in_variable_name Meaningful part of variable name, like "color" 1254 * @param in_block_name Name of block, like "input" 1255 * @param out_definition Definition string 1256 * @param out_reference Reference string 1257 **/ 1258 void Utils::prepareBlockVariableStrings(Utils::SHADER_STAGES in_stage, Utils::VARIABLE_STORAGE in_storage, 1259 const Utils::qualifierSet& in_qualifiers, const glw::GLchar* in_type_name, 1260 const glw::GLchar* in_variable_name, const glw::GLchar* in_block_name, 1261 std::string& out_definition, std::string& out_reference) 1262 { 1263 VARIABLE_FLAVOUR flavour = getVariableFlavour(in_stage, in_storage, in_qualifiers); 1264 const qualifierSet& qualifiers = prepareQualifiersSet(in_qualifiers, in_stage, in_storage); 1265 const std::string& name = getVariableName(in_stage, in_storage, in_variable_name); 1266 1267 out_definition = getBlockVariableDefinition(qualifiers, in_type_name, name.c_str()); 1268 out_reference = getBlockVariableReference(flavour, name.c_str(), in_block_name); 1269 } 1270 1271 /** Prepare definition and reference string for block varaible 1272 * 1273 * @param in_stage Shader stage 1274 * @param in_storage Storage of variable 1275 * @param in_qualifiers Set of qualifiers 1276 * @param in_type_name Type name 1277 * @param in_variable_name Meaningful part of variable name, like "color" 1278 * @param out_definition Definition string 1279 * @param out_reference Reference string 1280 **/ 1281 void Utils::prepareVariableStrings(Utils::SHADER_STAGES in_stage, Utils::VARIABLE_STORAGE in_storage, 1282 const Utils::qualifierSet& in_qualifiers, const glw::GLchar* in_type_name, 1283 const glw::GLchar* in_variable_name, std::string& out_definition, 1284 std::string& out_reference) 1285 { 1286 VARIABLE_FLAVOUR flavour = getVariableFlavour(in_stage, in_storage, in_qualifiers); 1287 const qualifierSet& qualifiers = prepareQualifiersSet(in_qualifiers, in_stage, in_storage); 1288 const std::string& name = getVariableName(in_stage, in_storage, in_variable_name); 1289 1290 out_definition = getVariableDefinition(flavour, qualifiers, in_type_name, name.c_str()); 1291 out_reference = getVariableReference(flavour, name.c_str()); 1292 } 1293 1294 /** Returns string with UTF8 character for current test case 1295 * 1296 * @return String with UTF8 character 1297 **/ 1298 const GLchar* Utils::getUtf8Character(Utils::UTF8_CHARACTERS character) 1299 { 1300 static const unsigned char two_bytes[] = { 0xd7, 0x84, 0x00 }; 1301 static const unsigned char three_bytes[] = { 0xe3, 0x82, 0x81, 0x00 }; 1302 static const unsigned char four_bytes[] = { 0xf0, 0x93, 0x83, 0x93, 0x00 }; 1303 static const unsigned char five_bytes[] = { 0xfa, 0x82, 0x82, 0x82, 0x82, 0x00 }; 1304 static const unsigned char six_bytes[] = { 0xfd, 0x82, 0x82, 0x82, 0x82, 0x82, 0x00 }; 1305 static const unsigned char redundant_bytes[] = { 0xf2, 0x80, 0x80, 0x5e, 0x00 }; 1306 1307 const GLchar* result = 0; 1308 1309 switch (character) 1310 { 1311 case TWO_BYTES: 1312 result = (const GLchar*)two_bytes; 1313 break; 1314 case THREE_BYTES: 1315 result = (const GLchar*)three_bytes; 1316 break; 1317 case FOUR_BYTES: 1318 result = (const GLchar*)four_bytes; 1319 break; 1320 case FIVE_BYTES: 1321 result = (const GLchar*)five_bytes; 1322 break; 1323 case SIX_BYTES: 1324 result = (const GLchar*)six_bytes; 1325 break; 1326 case REDUNDANT_ASCII: 1327 result = (const GLchar*)redundant_bytes; 1328 break; 1329 case EMPTY: 1330 result = ""; 1331 break; 1332 default: 1333 TCU_FAIL("Invalid enum"); 1334 } 1335 1336 return result; 1337 } 1338 /** Check if extension is supported 1339 * 1340 * @param context Test context 1341 * @param extension_name Name of extension 1342 * 1343 * @return true if extension is supported, false otherwise 1344 **/ 1345 bool Utils::isExtensionSupported(deqp::Context& context, const GLchar* extension_name) 1346 { 1347 const std::vector<std::string>& extensions = context.getContextInfo().getExtensions(); 1348 1349 if (std::find(extensions.begin(), extensions.end(), extension_name) == extensions.end()) 1350 { 1351 return false; 1352 } 1353 1354 return true; 1355 } 1356 1357 /** Check if GL context meets version requirements 1358 * 1359 * @param gl Functions 1360 * @param required_major Minimum required MAJOR_VERSION 1361 * @param required_minor Minimum required MINOR_VERSION 1362 * 1363 * @return true if GL context version is at least as requested, false otherwise 1364 **/ 1365 bool Utils::isGLVersionAtLeast(const glw::Functions& gl, glw::GLint required_major, glw::GLint required_minor) 1366 { 1367 glw::GLint major = 0; 1368 glw::GLint minor = 0; 1369 1370 gl.getIntegerv(GL_MAJOR_VERSION, &major); 1371 gl.getIntegerv(GL_MINOR_VERSION, &minor); 1372 1373 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 1374 1375 if (major > required_major) 1376 { 1377 /* Major is higher than required one */ 1378 return true; 1379 } 1380 else if (major == required_major) 1381 { 1382 if (minor >= required_minor) 1383 { 1384 /* Major is equal to required one */ 1385 /* Minor is higher than or equal to required one */ 1386 return true; 1387 } 1388 else 1389 { 1390 /* Major is equal to required one */ 1391 /* Minor is lower than required one */ 1392 return false; 1393 } 1394 } 1395 else 1396 { 1397 /* Major is lower than required one */ 1398 return false; 1399 } 1400 } 1401 1402 /** Replace first occurance of <token> with <text> in <string> starting at <search_posistion> 1403 * 1404 * @param token Token string 1405 * @param search_position Position at which find will start, it is updated to position at which replaced text ends 1406 * @param text String that will be used as replacement for <token> 1407 * @param string String to work on 1408 **/ 1409 void Utils::replaceToken(const glw::GLchar* token, size_t& search_position, const glw::GLchar* text, 1410 std::string& string) 1411 { 1412 const size_t text_length = strlen(text); 1413 const size_t token_length = strlen(token); 1414 const size_t token_position = string.find(token, search_position); 1415 1416 string.replace(token_position, token_length, text, text_length); 1417 1418 search_position = token_position + text_length; 1419 } 1420 1421 /** Replace all occurances of <token> with <text> in <string> 1422 * 1423 * @param token Token string 1424 * @param text String that will be used as replacement for <token> 1425 * @param string String to work on 1426 **/ 1427 void Utils::replaceAllTokens(const glw::GLchar* token, const glw::GLchar* text, std::string& string) 1428 { 1429 const size_t text_length = strlen(text); 1430 const size_t token_length = strlen(token); 1431 1432 size_t search_position = 0; 1433 1434 while (1) 1435 { 1436 const size_t token_position = string.find(token, search_position); 1437 1438 if (std::string::npos == token_position) 1439 { 1440 break; 1441 } 1442 1443 search_position = token_position + text_length; 1444 1445 string.replace(token_position, token_length, text, text_length); 1446 } 1447 } 1448 1449 /** Constructor 1450 * 1451 * @param context Test context 1452 * @param test_name Test name 1453 * @param test_description Test description 1454 **/ 1455 TestBase::TestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description) 1456 : TestCase(context, test_name, test_description) 1457 , m_is_compute_shader_supported(false) 1458 , m_is_explicit_uniform_location(false) 1459 , m_is_shader_language_420pack(false) 1460 { 1461 /* Nothing to be done here */ 1462 } 1463 1464 /** Execute test 1465 * 1466 * @return tcu::TestNode::CONTINUE after executing test case, tcu::TestNode::STOP otherwise 1467 **/ 1468 tcu::TestNode::IterateResult TestBase::iterate() 1469 { 1470 /* GL entry points */ 1471 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1472 1473 /* Check extension support and version */ 1474 m_is_explicit_uniform_location = Utils::isExtensionSupported(m_context, "GL_ARB_explicit_uniform_location"); 1475 m_is_shader_language_420pack = Utils::isExtensionSupported(m_context, "GL_ARB_shading_language_420pack"); 1476 m_is_compute_shader_supported = Utils::isGLVersionAtLeast(gl, 4, 3); 1477 1478 /* Execute test */ 1479 bool test_result = test(); 1480 1481 /* Set result */ 1482 if (true == test_result) 1483 { 1484 m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1485 } 1486 else 1487 { 1488 m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1489 } 1490 1491 /* Done */ 1492 return tcu::TestNode::STOP; 1493 } 1494 1495 /** Basic implementation of getShaderSourceConfig method. 1496 * 1497 * @param out_n_parts Number of source parts used by this test case 1498 * @param out_use_lengths If source lengths shall be provided to compiler 1499 **/ 1500 void TestBase::getShaderSourceConfig(glw::GLuint& out_n_parts, bool& out_use_lengths) 1501 { 1502 out_n_parts = 1; 1503 out_use_lengths = false; 1504 } 1505 1506 /** Basic implementation of prepareNextTestCase method. 1507 * 1508 * @param test_case_index Index of test case 1509 * 1510 * @return true if index is -1 or 0, false otherwise 1511 **/ 1512 bool TestBase::prepareNextTestCase(GLuint test_case_index) 1513 { 1514 if (((GLuint)-1 == test_case_index) || (0 == test_case_index)) 1515 { 1516 return true; 1517 } 1518 else 1519 { 1520 return false; 1521 } 1522 } 1523 1524 /** Basic implementation of prepareUniforms method 1525 * 1526 * @param ignored 1527 **/ 1528 void TestBase::prepareUniforms(Utils::program& /* program */) 1529 { 1530 /* Nothing to be done */ 1531 } 1532 1533 /** Basic implementation of testInit method 1534 * 1535 * @return true if test can be executed, false otherwise 1536 **/ 1537 bool TestBase::testInit() 1538 { 1539 return true; 1540 } 1541 1542 /** Get layout specific for given stage 1543 * 1544 * @param stage Shader stage 1545 * 1546 * @return Stage specific part 1547 **/ 1548 const GLchar* TestBase::getStageSpecificLayout(Utils::SHADER_STAGES stage) const 1549 { 1550 static const GLchar* stage_layout_geometry = "layout(points) in;\n" 1551 "layout(triangle_strip, max_vertices = 4) out;\n"; 1552 static const GLchar* stage_layout_tess_ctrl = "layout(vertices = 1) out;\n"; 1553 static const GLchar* stage_layout_tess_eval = "layout(isolines, point_mode) in;\n"; 1554 1555 const GLchar* result = ""; 1556 1557 switch (stage) 1558 { 1559 case Utils::GEOMETRY_SHADER: 1560 result = stage_layout_geometry; 1561 break; 1562 case Utils::TESS_CTRL_SHADER: 1563 result = stage_layout_tess_ctrl; 1564 break; 1565 case Utils::TESS_EVAL_SHADER: 1566 result = stage_layout_tess_eval; 1567 break; 1568 case Utils::VERTEX_SHADER: 1569 case Utils::FRAGMENT_SHADER: 1570 default: 1571 break; 1572 } 1573 1574 return result; 1575 } 1576 1577 /** Get "version" string 1578 * 1579 * @param stage Shader stage, compute shader will use 430 1580 * @param use_version_400 Select if 400 or 420 should be used 1581 * 1582 * @return Version string 1583 **/ 1584 const GLchar* TestBase::getVersionString(Utils::SHADER_STAGES stage, bool use_version_400) const 1585 { 1586 static const GLchar* version_400 = "#version 400\n" 1587 "#extension GL_ARB_shading_language_420pack : require\n" 1588 "#extension GL_ARB_separate_shader_objects : enable"; 1589 static const GLchar* version_420 = "#version 420"; 1590 static const GLchar* version_430 = "#version 430"; 1591 1592 const GLchar* result = ""; 1593 1594 if (Utils::COMPUTE_SHADER == stage) 1595 { 1596 result = version_430; 1597 } 1598 else if (true == use_version_400) 1599 { 1600 result = version_400; 1601 } 1602 else 1603 { 1604 result = version_420; 1605 } 1606 1607 return result; 1608 } 1609 1610 /** Initialize shaderSource instance, reserve storage and prepare shader source 1611 * 1612 * @param in_stage Shader stage 1613 * @param in_use_version_400 If version 400 or 420 should be used 1614 * @param out_source Shader source instance 1615 **/ 1616 void TestBase::initShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, Utils::shaderSource& out_source) 1617 { 1618 /* Shader source configuration */ 1619 glw::GLuint n_parts = 0; 1620 bool use_lengths = false; 1621 1622 getShaderSourceConfig(n_parts, use_lengths); 1623 1624 out_source.m_parts.resize(n_parts); 1625 out_source.m_use_lengths = use_lengths; 1626 1627 /* Request child class to prepare shader sources */ 1628 prepareShaderSource(in_stage, in_use_version_400, out_source); 1629 1630 /* Prepare source lengths */ 1631 if (true == use_lengths) 1632 { 1633 for (GLuint i = 0; i < n_parts; ++i) 1634 { 1635 out_source.m_parts[i].m_length = static_cast<glw::GLint>(out_source.m_parts[i].m_code.length()); 1636 1637 out_source.m_parts[i].m_code.append("This should be ignored by compiler, as source length is provided"); 1638 } 1639 } 1640 else 1641 { 1642 for (GLuint i = 0; i < n_parts; ++i) 1643 { 1644 out_source.m_parts[i].m_length = 0; 1645 } 1646 } 1647 } 1648 1649 /** Execute test 1650 * 1651 * @return true if test pass, false otherwise 1652 **/ 1653 bool TestBase::test() 1654 { 1655 bool result = true; 1656 GLuint test_case_index = 0; 1657 1658 /* Prepare test cases */ 1659 testInit(); 1660 1661 /* GL entry points */ 1662 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1663 1664 /* Tesselation patch set up */ 1665 gl.patchParameteri(GL_PATCH_VERTICES, 1); 1666 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 1667 1668 while (true == prepareNextTestCase(test_case_index)) 1669 { 1670 bool case_result = true; 1671 1672 /* Execute drawing case */ 1673 if (false == testDrawArray(false)) 1674 { 1675 case_result = false; 1676 } 1677 1678 if (true == m_is_shader_language_420pack) 1679 { 1680 if (false == testDrawArray(true)) 1681 { 1682 case_result = false; 1683 } 1684 } 1685 1686 /* Execute compute shader case */ 1687 if (true == m_is_compute_shader_supported) 1688 { 1689 if (false == testCompute()) 1690 { 1691 case_result = false; 1692 } 1693 } 1694 1695 /* Log failure */ 1696 if (false == case_result) 1697 { 1698 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Test case failed." 1699 << tcu::TestLog::EndMessage; 1700 1701 result = false; 1702 } 1703 1704 /* Go to next test case */ 1705 test_case_index += 1; 1706 } 1707 1708 /* Done */ 1709 return result; 1710 } 1711 1712 /** Constructor 1713 * 1714 * @param context Test context 1715 * @param test_name Name of test 1716 * @param test_description Description of test 1717 **/ 1718 APITestBase::APITestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description) 1719 : TestBase(context, test_name, test_description) 1720 { 1721 /* Nothing to be done here */ 1722 } 1723 1724 /** Execute test with compute shader 1725 * 1726 * @return true if test pass, false otherwise 1727 **/ 1728 bool APITestBase::testCompute() 1729 { 1730 /* GL objects */ 1731 Utils::program program(m_context); 1732 1733 /* Shaders */ 1734 Utils::shaderSource compute_shader; 1735 initShaderSource(Utils::COMPUTE_SHADER, false, compute_shader); 1736 1737 /* Check if test support compute shaders */ 1738 if (true == compute_shader.m_parts[0].m_code.empty()) 1739 { 1740 return true; 1741 } 1742 1743 /* Build program */ 1744 try 1745 { 1746 program.build(compute_shader, 0 /* fragment shader */, 0 /* geometry shader */, 1747 0 /* tesselation control shader */, 0 /* tesselation evaluation shader */, 0 /* vertex shader */, 1748 0 /* varying names */, 0 /* n varying names */, false); 1749 } 1750 catch (Utils::shaderCompilationException& exc) 1751 { 1752 /* Something wrong with compilation, test case failed */ 1753 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 1754 1755 message << "Shader compilation failed. Error message: " << exc.m_error_message; 1756 1757 Utils::program::printShaderSource(exc.m_shader_source, message); 1758 1759 message << tcu::TestLog::EndMessage; 1760 1761 return false; 1762 } 1763 catch (Utils::programLinkageException& exc) 1764 { 1765 /* Something wrong with linking, test case failed */ 1766 m_context.getTestContext().getLog() << tcu::TestLog::Message 1767 << "Program linking failed. Error message: " << exc.m_error_message 1768 << tcu::TestLog::EndMessage; 1769 return false; 1770 } 1771 1772 /* Set current program */ 1773 program.use(); 1774 1775 /* Return result of verification */ 1776 return checkResults(program); 1777 } 1778 1779 /** Execute test with VS, TCS, TES, GS and FS 1780 * 1781 * @param use_version_400 Select if 400 or 420 should be used 1782 * 1783 * @return true if test pass, false otherwise 1784 **/ 1785 bool APITestBase::testDrawArray(bool use_version_400) 1786 { 1787 /* GL objects */ 1788 Utils::program program(m_context); 1789 1790 /* Shaders */ 1791 Utils::shaderSource fragment_data; 1792 Utils::shaderSource geometry_data; 1793 Utils::shaderSource tess_ctrl_data; 1794 Utils::shaderSource tess_eval_data; 1795 Utils::shaderSource vertex_data; 1796 1797 initShaderSource(Utils::FRAGMENT_SHADER, use_version_400, fragment_data); 1798 initShaderSource(Utils::GEOMETRY_SHADER, use_version_400, geometry_data); 1799 initShaderSource(Utils::TESS_CTRL_SHADER, use_version_400, tess_ctrl_data); 1800 initShaderSource(Utils::TESS_EVAL_SHADER, use_version_400, tess_eval_data); 1801 initShaderSource(Utils::VERTEX_SHADER, use_version_400, vertex_data); 1802 1803 /* Build program */ 1804 try 1805 { 1806 program.build(0 /* compute shader */, fragment_data, geometry_data, tess_ctrl_data, tess_eval_data, vertex_data, 1807 0 /* varying names */, 0 /* n varying names */, false); 1808 } 1809 catch (Utils::shaderCompilationException& exc) 1810 { 1811 /* Something wrong with compilation, test case failed */ 1812 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 1813 1814 message << "Shader compilation failed. Error message: " << exc.m_error_message; 1815 1816 Utils::program::printShaderSource(exc.m_shader_source, message); 1817 1818 message << tcu::TestLog::EndMessage; 1819 1820 return false; 1821 } 1822 catch (Utils::programLinkageException& exc) 1823 { 1824 /* Something wrong with linking, test case failed */ 1825 m_context.getTestContext().getLog() << tcu::TestLog::Message 1826 << "Program linking failed. Error message: " << exc.m_error_message 1827 << tcu::TestLog::EndMessage; 1828 return false; 1829 } 1830 1831 /* Set current program */ 1832 program.use(); 1833 1834 /* Return result of verification */ 1835 return checkResults(program); 1836 } 1837 1838 /* Constants used by GLSLTestBase */ 1839 const glw::GLenum GLSLTestBase::m_color_texture_internal_format = GL_RGBA8; 1840 const glw::GLenum GLSLTestBase::m_color_texture_format = GL_RGBA; 1841 const glw::GLenum GLSLTestBase::m_color_texture_type = GL_UNSIGNED_BYTE; 1842 const glw::GLuint GLSLTestBase::m_color_texture_width = 16; 1843 const glw::GLuint GLSLTestBase::m_color_texture_height = 16; 1844 1845 /** Constructor 1846 * 1847 * @param context Test context 1848 * @param test_name Test name 1849 * @param test_description Test description 1850 **/ 1851 GLSLTestBase::GLSLTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description) 1852 : TestBase(context, test_name, test_description) 1853 { 1854 /* Nothing to be done here */ 1855 } 1856 1857 /** Basic implementation of prepareSourceTexture method. 1858 * 1859 * @param ignored Texture instance 1860 * 1861 * @return 0 1862 **/ 1863 const GLchar* GLSLTestBase::prepareSourceTexture(Utils::texture&) 1864 { 1865 return 0; 1866 } 1867 1868 /** Basic implementation of prepareVertexBuffer method. 1869 * 1870 * @param ignored Program instance 1871 * @param ignored Buffer instance 1872 * @param vao VertexArray instance 1873 * 1874 * @return 0 1875 **/ 1876 void GLSLTestBase::prepareVertexBuffer(const Utils::program&, Utils::buffer&, Utils::vertexArray& vao) 1877 { 1878 vao.generate(); 1879 vao.bind(); 1880 } 1881 1882 /** Basic implementation of verifyAdditionalResults 1883 * 1884 * @return true 1885 **/ 1886 bool GLSLTestBase::verifyAdditionalResults() const 1887 { 1888 return true; 1889 } 1890 1891 /** Basic implementation of releaseResource method 1892 * 1893 * @param ignored 1894 **/ 1895 void GLSLTestBase::releaseResource() 1896 { 1897 /* Nothing to be done */ 1898 } 1899 1900 /** Bind texture to first image unit and set image uniform to that unit 1901 * 1902 * @param program Program object 1903 * @param texture Texture object 1904 * @param uniform_name Name of image uniform 1905 **/ 1906 void GLSLTestBase::bindTextureToimage(Utils::program& program, Utils::texture& texture, 1907 const glw::GLchar* uniform_name) const 1908 { 1909 /* GL entry points */ 1910 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1911 1912 gl.bindImageTexture(0 /* unit */, texture.m_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */, GL_WRITE_ONLY, 1913 GL_RGBA8); 1914 GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); 1915 1916 GLint location = program.getUniformLocation(uniform_name); 1917 gl.uniform1i(location, 0); 1918 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); 1919 } 1920 1921 /** Bind texture to first texture unit and set sampler uniform to that unit 1922 * 1923 * @param program Program object 1924 * @param texture Texture object 1925 * @param uniform_name Name of sampler uniform 1926 **/ 1927 void GLSLTestBase::bindTextureToSampler(Utils::program& program, Utils::texture& texture, 1928 const glw::GLchar* uniform_name) const 1929 { 1930 /* GL entry points */ 1931 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1932 1933 gl.activeTexture(GL_TEXTURE0); 1934 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 1935 1936 texture.bind(); 1937 1938 GLint location = program.getUniformLocation(uniform_name); 1939 gl.uniform1i(location, 0); 1940 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); 1941 } 1942 1943 /** Check contents of texture. It is expected that it will be filled with green color 1944 * 1945 * @param color_texture Texture that will be verified 1946 * 1947 * @return true if texture is all green, false otherwise 1948 **/ 1949 bool GLSLTestBase::checkResults(Utils::texture& color_texture) const 1950 { 1951 static const GLuint green_color = 0xff00ff00; 1952 const GLuint texture_data_size = m_color_texture_width * m_color_texture_height; 1953 std::vector<glw::GLuint> texture_data; 1954 1955 texture_data.resize(texture_data_size); 1956 1957 color_texture.get(m_color_texture_format, m_color_texture_type, &texture_data[0]); 1958 1959 for (GLuint i = 0; i < texture_data_size; ++i) 1960 { 1961 if (green_color != texture_data[i]) 1962 { 1963 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Invalid texel: " << std::setbase(16) 1964 << std::setfill('0') << std::setw(8) << texture_data[i] 1965 << " at index: " << i << tcu::TestLog::EndMessage; 1966 1967 return false; 1968 } 1969 } 1970 1971 return verifyAdditionalResults(); 1972 } 1973 1974 /** Prepare framebuffer with texture used as attachment 1975 * 1976 * @param framebuffer Framebuffer 1977 * @param color_texture Textue used as color attachment 0 1978 **/ 1979 void GLSLTestBase::prepareFramebuffer(Utils::framebuffer& framebuffer, Utils::texture& color_texture) const 1980 { 1981 framebuffer.generate(); 1982 1983 color_texture.create(m_color_texture_width, m_color_texture_height, m_color_texture_internal_format); 1984 1985 framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_color_texture_width, m_color_texture_height); 1986 1987 framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 1988 framebuffer.clear(GL_COLOR_BUFFER_BIT); 1989 } 1990 1991 /** Prepare texture and bind it to image uniform 1992 * 1993 * @param framebuffer Framebuffer 1994 * @param color_texture Textue used as color attachment 0 1995 **/ 1996 void GLSLTestBase::prepareImage(Utils::program& program, Utils::texture& color_texture) const 1997 { 1998 color_texture.create(m_color_texture_width, m_color_texture_height, m_color_texture_internal_format); 1999 2000 bindTextureToimage(program, color_texture, "uni_image"); 2001 } 2002 2003 /** Execute test with compute shader 2004 * 2005 * @return true if test pass, false otherwise 2006 **/ 2007 bool GLSLTestBase::testCompute() 2008 { 2009 /* Test Result */ 2010 bool result = true; 2011 2012 /* GL objects */ 2013 Utils::texture color_tex(m_context); 2014 Utils::program program(m_context); 2015 Utils::texture source_tex(m_context); 2016 2017 /* Shaders */ 2018 Utils::shaderSource compute_shader; 2019 initShaderSource(Utils::COMPUTE_SHADER, false, compute_shader); 2020 2021 /* Check if test support compute shaders */ 2022 if (true == compute_shader.m_parts[0].m_code.empty()) 2023 { 2024 return true; 2025 } 2026 2027 /* Build program */ 2028 try 2029 { 2030 program.build(compute_shader, 0 /* fragment shader */, 0 /* geometry shader */, 2031 0 /* tesselation control shader */, 0 /* tesselation evaluation shader */, 0 /* vertex shader */, 2032 0 /* varying names */, 0 /* n varying names */, false); 2033 } 2034 catch (Utils::shaderCompilationException& exc) 2035 { 2036 /* Something wrong with compilation, test case failed */ 2037 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 2038 2039 message << "Shader compilation failed. Error message: " << exc.m_error_message; 2040 2041 Utils::program::printShaderSource(exc.m_shader_source, message); 2042 2043 message << tcu::TestLog::EndMessage; 2044 2045 return false; 2046 } 2047 catch (Utils::programLinkageException& exc) 2048 { 2049 /* Something wrong with linking, test case failed */ 2050 m_context.getTestContext().getLog() << tcu::TestLog::Message 2051 << "Program linking failed. Error message: " << exc.m_error_message 2052 << tcu::TestLog::EndMessage; 2053 return false; 2054 } 2055 2056 /* Log shaders, for debugging */ 2057 #if IS_DEBUG 2058 { 2059 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 2060 2061 Utils::program::printShaderSource(compute_shader, message); 2062 2063 message << tcu::TestLog::EndMessage; 2064 } 2065 #endif /* IS_DEBUG */ 2066 2067 /* Set current program */ 2068 program.use(); 2069 2070 /* Prepare image unit */ 2071 prepareImage(program, color_tex); 2072 2073 /* Test specific preparation of source texture */ 2074 const GLchar* sampler_name = prepareSourceTexture(source_tex); 2075 if (0 != sampler_name) 2076 { 2077 bindTextureToSampler(program, source_tex, sampler_name); 2078 } 2079 2080 /* Set up uniforms */ 2081 prepareUniforms(program); 2082 2083 /* GL entry points */ 2084 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2085 2086 /* Draw */ 2087 gl.dispatchCompute(m_color_texture_width, m_color_texture_height, 1); 2088 GLU_EXPECT_NO_ERROR(gl.getError(), "DispatchCompute"); 2089 2090 /* Return result of verification */ 2091 result = checkResults(color_tex); 2092 2093 /* Release extra resource for the test */ 2094 releaseResource(); 2095 2096 return result; 2097 } 2098 2099 /** Execute test with draw array operation 2100 * 2101 * @param use_version_400 Select if 400 or 420 should be used 2102 * 2103 * @return true if test pass, false otherwise 2104 **/ 2105 bool GLSLTestBase::testDrawArray(bool use_version_400) 2106 { 2107 /* Test Result */ 2108 bool result = true; 2109 2110 /* GL objects */ 2111 Utils::texture color_tex(m_context); 2112 Utils::framebuffer framebuffer(m_context); 2113 Utils::program program(m_context); 2114 Utils::texture source_tex(m_context); 2115 Utils::vertexArray vao(m_context); 2116 Utils::buffer vertex_buffer(m_context); 2117 2118 /* Shaders */ 2119 Utils::shaderSource fragment_data; 2120 Utils::shaderSource geometry_data; 2121 Utils::shaderSource tess_ctrl_data; 2122 Utils::shaderSource tess_eval_data; 2123 Utils::shaderSource vertex_data; 2124 2125 initShaderSource(Utils::FRAGMENT_SHADER, use_version_400, fragment_data); 2126 initShaderSource(Utils::GEOMETRY_SHADER, use_version_400, geometry_data); 2127 initShaderSource(Utils::TESS_CTRL_SHADER, use_version_400, tess_ctrl_data); 2128 initShaderSource(Utils::TESS_EVAL_SHADER, use_version_400, tess_eval_data); 2129 initShaderSource(Utils::VERTEX_SHADER, use_version_400, vertex_data); 2130 2131 /* Build program */ 2132 try 2133 { 2134 program.build(0 /* compute shader */, fragment_data, geometry_data, tess_ctrl_data, tess_eval_data, vertex_data, 2135 0 /* varying names */, 0 /* n varying names */, false); 2136 } 2137 catch (Utils::shaderCompilationException& exc) 2138 { 2139 /* Something wrong with compilation, test case failed */ 2140 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 2141 2142 message << "Shader compilation failed. Error message: " << exc.m_error_message; 2143 2144 Utils::program::printShaderSource(exc.m_shader_source, message); 2145 2146 message << tcu::TestLog::EndMessage; 2147 2148 return false; 2149 } 2150 catch (Utils::programLinkageException& exc) 2151 { 2152 /* Something wrong with linking, test case failed */ 2153 m_context.getTestContext().getLog() << tcu::TestLog::Message 2154 << "Program linking failed. Error message: " << exc.m_error_message 2155 << tcu::TestLog::EndMessage; 2156 return false; 2157 } 2158 2159 /* Log shaders, for debugging */ 2160 #if IS_DEBUG 2161 { 2162 const Utils::shaderSource* data[] = { &vertex_data, &tess_ctrl_data, &tess_eval_data, &geometry_data, 2163 &fragment_data }; 2164 2165 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 2166 2167 for (GLuint i = 0; i < 5; ++i) 2168 { 2169 Utils::program::printShaderSource(*data[i], message); 2170 } 2171 2172 message << tcu::TestLog::EndMessage; 2173 } 2174 #endif /* IS_DEBUG */ 2175 2176 /* Test specific preparation of vertex buffer and vao*/ 2177 prepareVertexBuffer(program, vertex_buffer, vao); 2178 2179 /* Set current program */ 2180 program.use(); 2181 2182 /* Prepare framebuffer */ 2183 prepareFramebuffer(framebuffer, color_tex); 2184 2185 /* Test specific preparation of source texture */ 2186 const GLchar* sampler_name = prepareSourceTexture(source_tex); 2187 if (0 != sampler_name) 2188 { 2189 bindTextureToSampler(program, source_tex, sampler_name); 2190 } 2191 2192 /* Set up uniforms */ 2193 prepareUniforms(program); 2194 2195 /* GL entry points */ 2196 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2197 2198 /* Draw */ 2199 gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */); 2200 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); 2201 2202 /* Return result of verification */ 2203 result = checkResults(color_tex); 2204 2205 /* Release extra resource for the test */ 2206 releaseResource(); 2207 2208 return result; 2209 } 2210 2211 /** Constructor 2212 * 2213 * @param context Test context 2214 * @param test_name Test name 2215 * @param test_description Test description 2216 **/ 2217 NegativeTestBase::NegativeTestBase(deqp::Context& context, const glw::GLchar* test_name, 2218 const glw::GLchar* test_description) 2219 : TestBase(context, test_name, test_description) 2220 { 2221 /* Nothing to be done here */ 2222 } 2223 2224 /** Execute test with compute shader 2225 * 2226 * @return true if test pass, false otherwise 2227 **/ 2228 bool NegativeTestBase::testCompute() 2229 { 2230 /* GL objects */ 2231 Utils::program program(m_context); 2232 2233 /* Shaders */ 2234 Utils::shaderSource conmpute_data; 2235 initShaderSource(Utils::COMPUTE_SHADER, false, conmpute_data); 2236 2237 /* Build program */ 2238 try 2239 { 2240 program.build(conmpute_data /* compute shader */, 0 /* fragment shader */, 0 /* geometry shader */, 2241 0 /* tesselation control shader */, 0 /* tesselation evaluation shader */, 0 /* vertex shader */, 2242 0 /* varying names */, 0 /* n varying names */, false); 2243 } 2244 catch (Utils::shaderCompilationException& exc) 2245 { 2246 /* Compilation failed, as expected. Verify that reason of failure is as expected */ 2247 m_context.getTestContext().getLog() << tcu::TestLog::Message 2248 << "Shader compilation error message: " << exc.m_error_message 2249 << tcu::TestLog::EndMessage; 2250 return true; 2251 } 2252 catch (Utils::programLinkageException& exc) 2253 { 2254 /* Something wrong with linking, test case failed */ 2255 m_context.getTestContext().getLog() << tcu::TestLog::Message 2256 << "Program linking failed. Error message: " << exc.m_error_message 2257 << tcu::TestLog::EndMessage; 2258 return true; 2259 } 2260 2261 /* Build process succeded */ 2262 return false; 2263 } 2264 2265 /** Execute test with draw array operation 2266 * 2267 * @param use_version_400 Select if 400 or 420 should be used 2268 * 2269 * @return true if test pass, false otherwise 2270 **/ 2271 bool NegativeTestBase::testDrawArray(bool use_version_400) 2272 { 2273 /* GL objects */ 2274 Utils::program program(m_context); 2275 2276 /* Shaders */ 2277 Utils::shaderSource fragment_data; 2278 Utils::shaderSource geometry_data; 2279 Utils::shaderSource tess_ctrl_data; 2280 Utils::shaderSource tess_eval_data; 2281 Utils::shaderSource vertex_data; 2282 2283 initShaderSource(Utils::FRAGMENT_SHADER, use_version_400, fragment_data); 2284 initShaderSource(Utils::GEOMETRY_SHADER, use_version_400, geometry_data); 2285 initShaderSource(Utils::TESS_CTRL_SHADER, use_version_400, tess_ctrl_data); 2286 initShaderSource(Utils::TESS_EVAL_SHADER, use_version_400, tess_eval_data); 2287 initShaderSource(Utils::VERTEX_SHADER, use_version_400, vertex_data); 2288 2289 /* Build program */ 2290 try 2291 { 2292 program.build(0 /* compute shader */, fragment_data, geometry_data, tess_ctrl_data, tess_eval_data, vertex_data, 2293 0 /* varying names */, 0 /* n varying names */, false); 2294 } 2295 catch (Utils::shaderCompilationException& exc) 2296 { 2297 /* Compilation failed, as expected. Verify that reason of failure is as expected */ 2298 m_context.getTestContext().getLog() << tcu::TestLog::Message 2299 << "Shader compilation error message: " << exc.m_error_message 2300 << tcu::TestLog::EndMessage; 2301 return true; 2302 } 2303 catch (Utils::programLinkageException& exc) 2304 { 2305 /* Something wrong with linking, test case failed */ 2306 m_context.getTestContext().getLog() << tcu::TestLog::Message 2307 << "Program linking failed. Error message: " << exc.m_error_message 2308 << tcu::TestLog::EndMessage; 2309 return true; 2310 } 2311 2312 /* Build process succeded */ 2313 return false; 2314 } 2315 2316 /* Constants used by BindingImageTest */ 2317 const GLuint BindingImageTest::m_width = 16; 2318 const GLuint BindingImageTest::m_green_color = 0xff00ff00; 2319 const GLuint BindingImageTest::m_height = 16; 2320 const GLuint BindingImageTest::m_depth = 6; 2321 2322 /** Constructor 2323 * 2324 * @param context Test context 2325 **/ 2326 BindingImageTest::BindingImageTest(deqp::Context& context, const glw::GLchar* test_name, 2327 const glw::GLchar* test_description) 2328 : GLSLTestBase(context, test_name, test_description) 2329 { 2330 /* Nothing to be done */ 2331 } 2332 2333 /** Prepare buffer, filled with given color 2334 * 2335 * @param buffer Buffer object 2336 * @param color Color 2337 **/ 2338 void BindingImageTest::prepareBuffer(Utils::buffer& buffer, GLuint color) 2339 { 2340 std::vector<GLuint> texture_data; 2341 texture_data.resize(m_width); 2342 2343 buffer.generate(GL_TEXTURE_BUFFER); 2344 2345 for (GLuint i = 0; i < texture_data.size(); ++i) 2346 { 2347 texture_data[i] = color; 2348 } 2349 2350 buffer.update(m_width * sizeof(GLuint), &texture_data[0], GL_STATIC_DRAW); 2351 } 2352 2353 /** Prepare texture of given type filled with given color and bind to specified image unit 2354 * 2355 * @param texture Texture 2356 * @param buffer Buffer 2357 * @param texture_type Type of texture 2358 * @param color Color 2359 **/ 2360 void BindingImageTest::prepareTexture(Utils::texture& texture, const Utils::buffer& buffer, 2361 Utils::TEXTURE_TYPES texture_type, GLuint color, GLuint unit) 2362 { 2363 std::vector<GLuint> texture_data; 2364 texture_data.resize(m_width * m_height * m_depth); 2365 2366 GLboolean is_layered = GL_FALSE; 2367 2368 for (GLuint i = 0; i < texture_data.size(); ++i) 2369 { 2370 texture_data[i] = color; 2371 } 2372 2373 if (Utils::TEX_BUFFER != texture_type) 2374 { 2375 texture.create(m_width, m_height, m_depth, GL_RGBA8, texture_type); 2376 2377 texture.update(m_width, m_height, m_depth, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 2378 } 2379 else 2380 { 2381 buffer.bind(); 2382 2383 texture.createBuffer(GL_RGBA8, buffer.m_id); 2384 } 2385 2386 switch (texture_type) 2387 { 2388 case Utils::TEX_1D_ARRAY: 2389 case Utils::TEX_2D_ARRAY: 2390 case Utils::TEX_3D: 2391 case Utils::TEX_CUBE: 2392 is_layered = GL_TRUE; 2393 break; 2394 default: 2395 break; 2396 } 2397 2398 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2399 2400 gl.bindImageTexture(unit, texture.m_id, 0 /* level */, is_layered /* layered */, 0 /* layer */, GL_READ_WRITE, 2401 GL_RGBA8); 2402 GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); 2403 } 2404 2405 /** Verifies that texel at offset 0 is green 2406 * 2407 * @param buffer Buffer object 2408 * 2409 * @return true if texel at offset 0 is green, false otherwise 2410 **/ 2411 bool BindingImageTest::verifyBuffer(const Utils::buffer& buffer) const 2412 { 2413 GLuint* data = (GLuint*)buffer.map(GL_READ_ONLY); 2414 2415 GLuint color = data[0]; 2416 2417 buffer.unmap(); 2418 2419 return (m_green_color == color); 2420 } 2421 2422 /** Verifies that texel at offset 0 is green 2423 * 2424 * @param buffer Buffer object 2425 * 2426 * @return true if texel at offset 0 is green, false otherwise 2427 **/ 2428 bool BindingImageTest::verifyTexture(const Utils::texture& texture) const 2429 { 2430 static const GLuint texture_data_size = m_width * m_height * m_depth; 2431 2432 std::vector<glw::GLuint> texture_data; 2433 texture_data.resize(texture_data_size); 2434 2435 texture.get(GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 2436 2437 GLuint color = texture_data[0]; 2438 2439 return (m_green_color == color); 2440 } 2441 2442 /* Constants used by LineContinuationTest */ 2443 const GLuint LineContinuationTest::m_n_repetitions = 20; 2444 const GLchar* LineContinuationTest::m_texture_coordinates_name = "texture_coordinates"; 2445 2446 /** Constructor 2447 * 2448 * @param context Test context 2449 **/ 2450 LineContinuationTest::LineContinuationTest(deqp::Context& context) : GLSLTestBase(context, "line_continuation", "desc") 2451 { 2452 /* Nothing to be done here */ 2453 } 2454 2455 /** Overwrite getShaderSourceConfig method 2456 * 2457 * @param out_n_parts Number of source parts used by this test case 2458 * @param out_use_lengths If source lengths shall be provided to compiler 2459 **/ 2460 void LineContinuationTest::getShaderSourceConfig(GLuint& out_n_parts, bool& out_use_lengths) 2461 { 2462 out_n_parts = (true == isShaderMultipart()) ? 2 : 1; 2463 out_use_lengths = useSourceLengths(); 2464 } 2465 2466 /** Set up next test case 2467 * 2468 * @param test_case_index Index of next test case 2469 * 2470 * @return false if there is no more test cases, true otherwise 2471 **/ 2472 bool LineContinuationTest::prepareNextTestCase(glw::GLuint test_case_index) 2473 { 2474 static const testCase test_cases[] = { { ASSIGNMENT_BEFORE_OPERATOR, ONCE, UNIX }, 2475 { ASSIGNMENT_BEFORE_OPERATOR, ONCE, DOS }, 2476 { ASSIGNMENT_BEFORE_OPERATOR, MULTIPLE_TIMES, UNIX }, 2477 { ASSIGNMENT_BEFORE_OPERATOR, MULTIPLE_TIMES, DOS }, 2478 { ASSIGNMENT_AFTER_OPERATOR, ONCE, UNIX }, 2479 { ASSIGNMENT_AFTER_OPERATOR, ONCE, DOS }, 2480 { ASSIGNMENT_AFTER_OPERATOR, MULTIPLE_TIMES, UNIX }, 2481 { ASSIGNMENT_AFTER_OPERATOR, MULTIPLE_TIMES, DOS }, 2482 { VECTOR_VARIABLE_INITIALIZER, ONCE, UNIX }, 2483 { VECTOR_VARIABLE_INITIALIZER, ONCE, DOS }, 2484 { VECTOR_VARIABLE_INITIALIZER, MULTIPLE_TIMES, UNIX }, 2485 { VECTOR_VARIABLE_INITIALIZER, MULTIPLE_TIMES, DOS }, 2486 { TOKEN_INSIDE_FUNCTION_NAME, ONCE, UNIX }, 2487 { TOKEN_INSIDE_FUNCTION_NAME, ONCE, DOS }, 2488 { TOKEN_INSIDE_FUNCTION_NAME, MULTIPLE_TIMES, UNIX }, 2489 { TOKEN_INSIDE_FUNCTION_NAME, MULTIPLE_TIMES, DOS }, 2490 { TOKEN_INSIDE_TYPE_NAME, ONCE, UNIX }, 2491 { TOKEN_INSIDE_TYPE_NAME, ONCE, DOS }, 2492 { TOKEN_INSIDE_TYPE_NAME, MULTIPLE_TIMES, UNIX }, 2493 { TOKEN_INSIDE_TYPE_NAME, MULTIPLE_TIMES, DOS }, 2494 { TOKEN_INSIDE_VARIABLE_NAME, ONCE, UNIX }, 2495 { TOKEN_INSIDE_VARIABLE_NAME, ONCE, DOS }, 2496 { TOKEN_INSIDE_VARIABLE_NAME, MULTIPLE_TIMES, UNIX }, 2497 { TOKEN_INSIDE_VARIABLE_NAME, MULTIPLE_TIMES, DOS }, 2498 { PREPROCESSOR_TOKEN_INSIDE, ONCE, UNIX }, 2499 { PREPROCESSOR_TOKEN_INSIDE, ONCE, DOS }, 2500 { PREPROCESSOR_TOKEN_INSIDE, MULTIPLE_TIMES, UNIX }, 2501 { PREPROCESSOR_TOKEN_INSIDE, MULTIPLE_TIMES, DOS }, 2502 { PREPROCESSOR_TOKEN_BETWEEN, ONCE, UNIX }, 2503 { PREPROCESSOR_TOKEN_BETWEEN, ONCE, DOS }, 2504 { PREPROCESSOR_TOKEN_BETWEEN, MULTIPLE_TIMES, UNIX }, 2505 { PREPROCESSOR_TOKEN_BETWEEN, MULTIPLE_TIMES, DOS }, 2506 { COMMENT, ONCE, UNIX }, 2507 { COMMENT, ONCE, DOS }, 2508 { COMMENT, MULTIPLE_TIMES, UNIX }, 2509 { COMMENT, MULTIPLE_TIMES, DOS }, 2510 { SOURCE_TERMINATION_NULL, ONCE, UNIX }, 2511 { SOURCE_TERMINATION_NULL, ONCE, DOS }, 2512 { SOURCE_TERMINATION_NULL, MULTIPLE_TIMES, UNIX }, 2513 { SOURCE_TERMINATION_NULL, MULTIPLE_TIMES, DOS }, 2514 { SOURCE_TERMINATION_NON_NULL, ONCE, UNIX }, 2515 { SOURCE_TERMINATION_NON_NULL, ONCE, DOS }, 2516 { SOURCE_TERMINATION_NON_NULL, MULTIPLE_TIMES, UNIX }, 2517 { SOURCE_TERMINATION_NON_NULL, MULTIPLE_TIMES, DOS }, 2518 { PART_TERMINATION_NULL, ONCE, UNIX }, 2519 { PART_TERMINATION_NULL, ONCE, DOS }, 2520 { PART_TERMINATION_NULL, MULTIPLE_TIMES, UNIX }, 2521 { PART_TERMINATION_NULL, MULTIPLE_TIMES, DOS }, 2522 { PART_NEXT_TO_TERMINATION_NULL, ONCE, UNIX }, 2523 { PART_NEXT_TO_TERMINATION_NULL, ONCE, DOS }, 2524 { PART_NEXT_TO_TERMINATION_NULL, MULTIPLE_TIMES, UNIX }, 2525 { PART_NEXT_TO_TERMINATION_NULL, MULTIPLE_TIMES, DOS }, 2526 { PART_TERMINATION_NON_NULL, ONCE, UNIX }, 2527 { PART_TERMINATION_NON_NULL, ONCE, DOS }, 2528 { PART_TERMINATION_NON_NULL, MULTIPLE_TIMES, UNIX }, 2529 { PART_TERMINATION_NON_NULL, MULTIPLE_TIMES, DOS }, 2530 { PART_NEXT_TO_TERMINATION_NON_NULL, ONCE, UNIX }, 2531 { PART_NEXT_TO_TERMINATION_NON_NULL, ONCE, DOS }, 2532 { PART_NEXT_TO_TERMINATION_NON_NULL, MULTIPLE_TIMES, UNIX }, 2533 { PART_NEXT_TO_TERMINATION_NON_NULL, MULTIPLE_TIMES, DOS } }; 2534 2535 static const GLuint max_test_cases = sizeof(test_cases) / sizeof(testCase); 2536 2537 if ((GLuint)-1 == test_case_index) 2538 { 2539 m_test_case.m_case = DEBUG_CASE; 2540 } 2541 else if (max_test_cases <= test_case_index) 2542 { 2543 return false; 2544 } 2545 else 2546 { 2547 m_test_case = test_cases[test_case_index]; 2548 } 2549 2550 m_context.getTestContext().getLog() << tcu::TestLog::Message 2551 << "Test case: " << repetitionsToStr((REPETITIONS)m_test_case.m_repetitions) 2552 << " line continuation, with " 2553 << lineEndingsToStr((LINE_ENDINGS)m_test_case.m_line_endings) 2554 << " line endings, is placed " << casesToStr((CASES)m_test_case.m_case) 2555 << tcu::TestLog::EndMessage; 2556 2557 return true; 2558 } 2559 2560 /** Prepare source for given shader stage 2561 * 2562 * @param in_stage Shader stage, compute shader will use 430 2563 * @param in_use_version_400 Select if 400 or 420 should be used 2564 * @param out_source Prepared shader source instance 2565 **/ 2566 void LineContinuationTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 2567 Utils::shaderSource& out_source) 2568 { 2569 if (Utils::COMPUTE_SHADER == in_stage) 2570 { 2571 prepareComputShaderSource(out_source); 2572 } 2573 else 2574 { 2575 prepareShaderSourceForDraw(in_stage, in_use_version_400, out_source); 2576 } 2577 } 2578 2579 /** Prepare compute shader source 2580 * 2581 * @param source Result shader source 2582 **/ 2583 void LineContinuationTest::prepareComputShaderSource(Utils::shaderSource& source) 2584 { 2585 static const GLchar* shader_template_part_0 = 2586 "#version 430\n" 2587 "\n" 2588 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 2589 "\n" 2590 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 2591 "\n" 2592 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 2593 "\n" 2594 "writeonly uniform image2D uni_image;\n" 2595 " uniform sampler2D uni_sampler;\n" 2596 "\n" 2597 "void funFUNCTION_CASEction(in veTYPE_CASEc4 in_vVARIABLE_CASEalue)\n" 2598 "{\n" 2599 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), inVARIABLE_CASE_value);\n" 2600 "}\n" 2601 "\n" 2602 "#define SET_PREPROCESSOR_INSIDE_CASERESULT(XX) " 2603 "PREPROCESSOR_BETWEEN_CASEfuncFUNCTION_CASEtion(XPREPROCESSOR_INSIDE_CASEX)\n" 2604 "NEXT_TO_TERMINATION_CASE\nTERMINATION_CASE"; 2605 2606 static const GLchar* shader_template_part_1 = 2607 "void main()\n" 2608 "{\n" 2609 " ivec2 coordinates ASSIGNMENT_BEFORE_OPERATOR_CASE=ASSIGNMENT_AFTER_OPERATOR_CASE " 2610 "ivec2(gl_GlobalInvocationID.xy + ivec2(16, 16));\n" 2611 " vec4 sampled_color = texelFetch(uni_sampler, coordinates, 0 /* lod */);\n" 2612 " vec4 result = vec4(0, 0VECTOR_VARIABLE_INITIALIZER_CASE, 0, 1);\n" 2613 "\n" 2614 " if (vec4(0, 0, 1, 1) == sampled_color)\n" 2615 " {\n" 2616 " result = vecTYPE_CASE4(VECTOR_VARIABLE_INITIALIZER_CASE0, 1, 0, 1);\n" 2617 " }\n" 2618 " else\n" 2619 " {\n" 2620 " result = vec4(coordinates.xy, sampled_color.rg);\n" 2621 " }\n" 2622 "\n" 2623 " SET_RESULT(result);" 2624 "}\n"; 2625 2626 /* Init strings with templates and replace all CASE tokens */ 2627 if (true == isShaderMultipart()) 2628 { 2629 source.m_parts[0].m_code = shader_template_part_0; 2630 source.m_parts[1].m_code = shader_template_part_1; 2631 2632 replaceAllCaseTokens(source.m_parts[0].m_code); 2633 replaceAllCaseTokens(source.m_parts[1].m_code); 2634 } 2635 else 2636 { 2637 source.m_parts[0].m_code = shader_template_part_0; 2638 source.m_parts[0].m_code.append(shader_template_part_1); 2639 2640 replaceAllCaseTokens(source.m_parts[0].m_code); 2641 } 2642 } 2643 2644 /** Prepare source for given shader stage 2645 * 2646 * @param stage Shader stage, compute shader will use 430 2647 * @param use_version_400 Select if 400 or 420 should be used 2648 * @param source Result shader sources 2649 **/ 2650 void LineContinuationTest::prepareShaderSourceForDraw(Utils::SHADER_STAGES stage, bool use_version_400, 2651 Utils::shaderSource& source) 2652 { 2653 /* Templates */ 2654 static const GLchar* shader_template_part_0 = 2655 "VERSION\n" 2656 "\n" 2657 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 2658 "\n" 2659 "STAGE_SPECIFIC\n" 2660 "\n" 2661 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 2662 "\n" 2663 "IN_COLOR_DEFINITION\n" 2664 "IN_TEXTURE_COORDINATES_DEFINITION\n" 2665 "OUT_COLOR_DEFINITION\n" 2666 "OUT_TEXTURE_COORDINATES_DEFINITION\n" 2667 "uniform sampler2D uni_sampler;\n" 2668 "\n" 2669 "void funFUNCTION_CASEction(in veTYPE_CASEc4 in_vVARIABLE_CASEalue)\n" 2670 "{\n" 2671 " OUT_COLOR ASSIGNMENT_BEFORE_OPERATOR_CASE=ASSIGNMENT_AFTER_OPERATOR_CASE inVARIABLE_CASE_value;\n" 2672 "}\n" 2673 "\n" 2674 "#define SET_PREPROCESSOR_INSIDE_CASERESULT(XX) " 2675 "PREPROCESSOR_BETWEEN_CASEfuncFUNCTION_CASEtion(XPREPROCESSOR_INSIDE_CASEX)\n" 2676 "NEXT_TO_TERMINATION_CASE\nTERMINATION_CASE"; 2677 2678 static const GLchar* shader_template_part_1 = 2679 "void main()\n" 2680 "{\n" 2681 " vec2 coordinates = TEXTURE_COORDINATES;\n" 2682 " vec4 sampled_color = texture(uni_sampler, coordinates);\n" 2683 " vec4 result = vec4(0, 0VECTOR_VARIABLE_INITIALIZER_CASE, 0, 1);\n" 2684 "\n" 2685 " if (PASS_CONDITION)\n" 2686 " {\n" 2687 " result = vecTYPE_CASE4(VECTOR_VARIABLE_INITIALIZER_CASE0, 1, 0, 1);\n" 2688 " }\n" 2689 " else\n" 2690 " {\n" 2691 " result = vec4(coordinates.xy, sampled_color.rg);\n" 2692 " }\n" 2693 "\n" 2694 "STORE_RESULTS" 2695 "}\n" 2696 "NEXT_TO_TERMINATION_CASE\nTERMINATION_CASE"; 2697 2698 static const GLchar* store_results_template = " SET_RESULT(result);\n" 2699 " TEXTURE_COORDINATES = coordinates;\n"; 2700 2701 static const GLchar* store_results_tcs_template = " SET_RESULT(result);\n" 2702 " TEXTURE_COORDINATES = coordinates;\n" 2703 " gl_TessLevelOuter[0] = 1.0;\n" 2704 " gl_TessLevelOuter[1] = 1.0;\n" 2705 " gl_TessLevelOuter[2] = 1.0;\n" 2706 " gl_TessLevelOuter[3] = 1.0;\n" 2707 " gl_TessLevelInner[0] = 1.0;\n" 2708 " gl_TessLevelInner[1] = 1.0;\n"; 2709 2710 static const GLchar* store_results_fs_template = " SET_RESULT(result);\n"; 2711 2712 static const GLchar* store_results_gs_template = " gl_Position = vec4(-1, -1, 0, 1);\n" 2713 " SET_RESULT(result);\n" 2714 " TEXTURE_COORDINATES = coordinates + vec2(-0.25, -0.25);\n" 2715 " EmitVertex();\n" 2716 " gl_Position = vec4(-1, 1, 0, 1);\n" 2717 " SET_RESULT(result);\n" 2718 " TEXTURE_COORDINATES = coordinates + vec2(-0.25, 0.25);\n" 2719 " EmitVertex();\n" 2720 " gl_Position = vec4(1, -1, 0, 1);\n" 2721 " SET_RESULT(result);\n" 2722 " TEXTURE_COORDINATES = coordinates + vec2(0.25, -0.25);\n" 2723 " EmitVertex();\n" 2724 " gl_Position = vec4(1, 1, 0, 1);\n" 2725 " SET_RESULT(result);\n" 2726 " TEXTURE_COORDINATES = coordinates + vec2(0.25, 0.25);\n" 2727 " EmitVertex();\n"; 2728 2729 static const GLchar* pass_condition_template = "(EXPECTED_VALUE == sampled_color) &&\n" 2730 " (vec4(0, 1, 0, 1) == IN_COLOR) "; 2731 2732 static const GLchar* pass_condition_vs_template = "EXPECTED_VALUE == sampled_color"; 2733 2734 /* Tokens to be replaced with GLSL stuff */ 2735 static const GLchar* token_version = "VERSION"; 2736 static const GLchar* token_stage_specific = "STAGE_SPECIFIC"; 2737 2738 static const GLchar* token_in_color_definition = "IN_COLOR_DEFINITION"; 2739 static const GLchar* token_in_tex_coord_definition = "IN_TEXTURE_COORDINATES_DEFINITION"; 2740 static const GLchar* token_out_color_definition = "OUT_COLOR_DEFINITION"; 2741 static const GLchar* token_out_tex_coord_definition = "OUT_TEXTURE_COORDINATES_DEFINITION"; 2742 2743 static const GLchar* token_expected_value = "EXPECTED_VALUE"; 2744 static const GLchar* token_texture_coordinates = "TEXTURE_COORDINATES"; 2745 static const GLchar* token_in_color = "IN_COLOR"; 2746 static const GLchar* token_out_color = "OUT_COLOR"; 2747 2748 static const GLchar* token_store_results = "STORE_RESULTS"; 2749 static const GLchar* token_pass_condition = "PASS_CONDITION"; 2750 2751 /* Name of variable and empty string*/ 2752 static const GLchar* color_name = "color"; 2753 static const GLchar* empty = ""; 2754 2755 /* GLSL stuff */ 2756 const GLchar* version = getVersionString(stage, use_version_400); 2757 const GLchar* stage_specific_layout = getStageSpecificLayout(stage); 2758 const GLchar* expected_value = getExpectedValueString(); 2759 2760 /* Qualifiers */ 2761 Utils::qualifierSet in; 2762 Utils::qualifierSet out; 2763 in.push_back(Utils::QUAL_IN); 2764 out.push_back(Utils::QUAL_OUT); 2765 2766 /* In/Out variables definitions and references */ 2767 std::string in_tex_coord_reference; 2768 std::string out_tex_coord_reference; 2769 std::string in_color_reference; 2770 std::string out_color_reference; 2771 std::string in_tex_coord_definition; 2772 std::string out_tex_coord_definition; 2773 std::string in_color_definition; 2774 std::string out_color_definition; 2775 2776 Utils::prepareVariableStrings(stage, Utils::INPUT, in, "vec2", m_texture_coordinates_name, in_tex_coord_definition, 2777 in_tex_coord_reference); 2778 Utils::prepareVariableStrings(stage, Utils::OUTPUT, out, "vec2", m_texture_coordinates_name, 2779 out_tex_coord_definition, out_tex_coord_reference); 2780 Utils::prepareVariableStrings(stage, Utils::INPUT, in, "vec4", color_name, in_color_definition, in_color_reference); 2781 Utils::prepareVariableStrings(stage, Utils::OUTPUT, out, "vec4", color_name, out_color_definition, 2782 out_color_reference); 2783 2784 in_tex_coord_definition.append(";"); 2785 out_tex_coord_definition.append(";"); 2786 in_color_definition.append(";"); 2787 out_color_definition.append(";"); 2788 2789 /* Select pass condition and store results tempaltes */ 2790 const GLchar* store_results = store_results_template; 2791 const GLchar* pass_condition = pass_condition_template; 2792 2793 switch (stage) 2794 { 2795 case Utils::FRAGMENT_SHADER: 2796 store_results = store_results_fs_template; 2797 break; 2798 case Utils::GEOMETRY_SHADER: 2799 store_results = store_results_gs_template; 2800 break; 2801 case Utils::TESS_CTRL_SHADER: 2802 store_results = store_results_tcs_template; 2803 break; 2804 case Utils::VERTEX_SHADER: 2805 pass_condition = pass_condition_vs_template; 2806 break; 2807 default: 2808 break; 2809 }; 2810 const GLuint store_results_length = static_cast<GLuint>(strlen(store_results)); 2811 const GLuint pass_condition_length = static_cast<GLuint>(strlen(pass_condition)); 2812 2813 /* Init strings with templates and replace all CASE tokens */ 2814 if (true == isShaderMultipart()) 2815 { 2816 source.m_parts[0].m_code = shader_template_part_0; 2817 source.m_parts[1].m_code = shader_template_part_1; 2818 2819 replaceAllCaseTokens(source.m_parts[0].m_code); 2820 replaceAllCaseTokens(source.m_parts[1].m_code); 2821 } 2822 else 2823 { 2824 source.m_parts[0].m_code = shader_template_part_0; 2825 source.m_parts[0].m_code.append(shader_template_part_1); 2826 2827 replaceAllCaseTokens(source.m_parts[0].m_code); 2828 } 2829 2830 /* Get memory for shader source parts */ 2831 const bool is_multipart = isShaderMultipart(); 2832 size_t position = 0; 2833 std::string& shader_source_part_0 = source.m_parts[0].m_code; 2834 std::string& shader_source_part_1 = (true == is_multipart) ? source.m_parts[1].m_code : source.m_parts[0].m_code; 2835 2836 /* Replace tokens */ 2837 /* Part 0 */ 2838 Utils::replaceToken(token_version, position, version, shader_source_part_0); 2839 2840 Utils::replaceToken(token_stage_specific, position, stage_specific_layout, shader_source_part_0); 2841 2842 if (Utils::VERTEX_SHADER != stage) 2843 { 2844 Utils::replaceToken(token_in_color_definition, position, in_color_definition.c_str(), shader_source_part_0); 2845 } 2846 else 2847 { 2848 Utils::replaceToken(token_in_color_definition, position, empty, shader_source_part_0); 2849 } 2850 Utils::replaceToken(token_in_tex_coord_definition, position, in_tex_coord_definition.c_str(), shader_source_part_0); 2851 Utils::replaceToken(token_out_color_definition, position, out_color_definition.c_str(), shader_source_part_0); 2852 if (Utils::FRAGMENT_SHADER == stage) 2853 { 2854 Utils::replaceToken(token_out_tex_coord_definition, position, empty, shader_source_part_0); 2855 } 2856 else 2857 { 2858 Utils::replaceToken(token_out_tex_coord_definition, position, out_tex_coord_definition.c_str(), 2859 shader_source_part_0); 2860 } 2861 2862 Utils::replaceToken(token_out_color, position, out_color_reference.c_str(), shader_source_part_0); 2863 2864 /* Part 1 */ 2865 if (true == is_multipart) 2866 { 2867 position = 0; 2868 } 2869 2870 Utils::replaceToken(token_texture_coordinates, position, in_tex_coord_reference.c_str(), shader_source_part_1); 2871 2872 Utils::replaceToken(token_pass_condition, position, pass_condition, shader_source_part_1); 2873 position -= pass_condition_length; 2874 2875 Utils::replaceToken(token_expected_value, position, expected_value, shader_source_part_1); 2876 if (Utils::VERTEX_SHADER != stage) 2877 { 2878 Utils::replaceToken(token_in_color, position, in_color_reference.c_str(), shader_source_part_1); 2879 } 2880 2881 Utils::replaceToken(token_store_results, position, store_results, shader_source_part_1); 2882 position -= store_results_length; 2883 2884 if (Utils::GEOMETRY_SHADER == stage) 2885 { 2886 for (GLuint i = 0; i < 4; ++i) 2887 { 2888 Utils::replaceToken(token_texture_coordinates, position, out_tex_coord_reference.c_str(), 2889 shader_source_part_1); 2890 } 2891 } 2892 else if (Utils::FRAGMENT_SHADER == stage) 2893 { 2894 /* Nothing to be done */ 2895 } 2896 else 2897 { 2898 Utils::replaceToken(token_texture_coordinates, position, out_tex_coord_reference.c_str(), shader_source_part_1); 2899 } 2900 } 2901 2902 /** Prepare texture 2903 * 2904 * @param texture Texutre to be created and filled with content 2905 * 2906 * @return Name of sampler uniform that should be used for the texture 2907 **/ 2908 const GLchar* LineContinuationTest::prepareSourceTexture(Utils::texture& texture) 2909 { 2910 std::vector<GLuint> data; 2911 static const GLuint width = 64; 2912 static const GLuint height = 64; 2913 static const GLuint data_size = width * height; 2914 static const GLuint blue_color = 0xffff0000; 2915 static const GLuint grey_color = 0xaaaaaaaa; 2916 2917 data.resize(data_size); 2918 2919 for (GLuint i = 0; i < data_size; ++i) 2920 { 2921 data[i] = grey_color; 2922 } 2923 2924 for (GLuint y = 16; y < 48; ++y) 2925 { 2926 const GLuint line_offset = y * 64; 2927 2928 for (GLuint x = 16; x < 48; ++x) 2929 { 2930 const GLuint pixel_offset = x + line_offset; 2931 2932 data[pixel_offset] = blue_color; 2933 } 2934 } 2935 2936 texture.create(width, height, GL_RGBA8); 2937 2938 texture.update(width, height, 0 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]); 2939 2940 return "uni_sampler"; 2941 } 2942 2943 /** Prepare vertex buffer, vec2 tex_coord 2944 * 2945 * @param program Program object 2946 * @param buffer Vertex buffer 2947 * @param vao Vertex array object 2948 **/ 2949 void LineContinuationTest::prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, 2950 Utils::vertexArray& vao) 2951 { 2952 std::string tex_coord_name = Utils::getVariableName(Utils::VERTEX_SHADER, Utils::INPUT, m_texture_coordinates_name); 2953 GLint tex_coord_loc = program.getAttribLocation(tex_coord_name.c_str()); 2954 2955 if (-1 == tex_coord_loc) 2956 { 2957 TCU_FAIL("Vertex attribute location is invalid"); 2958 } 2959 2960 vao.generate(); 2961 vao.bind(); 2962 2963 buffer.generate(GL_ARRAY_BUFFER); 2964 2965 GLfloat data[] = { 0.5f, 0.5f, 0.5f, 0.5f }; 2966 GLsizeiptr data_size = sizeof(data); 2967 2968 buffer.update(data_size, data, GL_STATIC_DRAW); 2969 2970 /* GL entry points */ 2971 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2972 2973 /* Set up vao */ 2974 gl.vertexAttribPointer(tex_coord_loc, 2 /* size */, GL_FLOAT /* type */, GL_FALSE /* normalized*/, 0 /* stride */, 2975 0 /* offset */); 2976 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer"); 2977 2978 /* Enable attribute */ 2979 gl.enableVertexAttribArray(tex_coord_loc); 2980 GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray"); 2981 } 2982 2983 /** Get string describing test cases 2984 * 2985 * @param cases Test case 2986 * 2987 * @return String describing current test case 2988 **/ 2989 const GLchar* LineContinuationTest::casesToStr(CASES cases) const 2990 { 2991 const GLchar* result = 0; 2992 switch (cases) 2993 { 2994 case ASSIGNMENT_BEFORE_OPERATOR: 2995 result = "just before assignment operator"; 2996 break; 2997 case ASSIGNMENT_AFTER_OPERATOR: 2998 result = "just after assignment operator"; 2999 break; 3000 case VECTOR_VARIABLE_INITIALIZER: 3001 result = "inside vector variable initializer"; 3002 break; 3003 case TOKEN_INSIDE_FUNCTION_NAME: 3004 result = "inside function name"; 3005 break; 3006 case TOKEN_INSIDE_TYPE_NAME: 3007 result = "inside type name"; 3008 break; 3009 case TOKEN_INSIDE_VARIABLE_NAME: 3010 result = "inside variable name"; 3011 break; 3012 case PREPROCESSOR_TOKEN_INSIDE: 3013 result = "inside preprocessor token"; 3014 break; 3015 case PREPROCESSOR_TOKEN_BETWEEN: 3016 result = "between preprocessor token"; 3017 break; 3018 case COMMENT: 3019 result = "inside comment"; 3020 break; 3021 case SOURCE_TERMINATION_NULL: 3022 result = "just before null terminating source"; 3023 break; 3024 case SOURCE_TERMINATION_NON_NULL: 3025 result = "as last character in source string, without null termination"; 3026 break; 3027 case PART_TERMINATION_NULL: 3028 result = "just before null terminating part of source"; 3029 break; 3030 case PART_NEXT_TO_TERMINATION_NULL: 3031 result = "just before last character in part of source"; 3032 break; 3033 case PART_TERMINATION_NON_NULL: 3034 result = "as last character in part string, without null termination"; 3035 break; 3036 case PART_NEXT_TO_TERMINATION_NON_NULL: 3037 result = "just before last character in part string, without null termination"; 3038 break; 3039 case DEBUG_CASE: /* intended fall through */ 3040 default: 3041 result = "nowhere at all. This is debug!"; 3042 break; 3043 } 3044 3045 return result; 3046 } 3047 3048 /** Get expected value, blue color as vec4 3049 * 3050 * @return blue color 3051 **/ 3052 const GLchar* LineContinuationTest::getExpectedValueString() const 3053 { 3054 return "vec4(0, 0, 1, 1)"; 3055 } 3056 3057 /** Get line continuation string, single or multiple \ 3058 * 3059 * @return String 3060 **/ 3061 std::string LineContinuationTest::getLineContinuationString() const 3062 { 3063 static const GLchar line_continuation_ending_dos[] = { '\\', 0x0d, 0x0a, 0x00 }; 3064 static const GLchar line_continuation_ending_unix[] = { '\\', 0x0a, 0x00 }; 3065 3066 std::string result; 3067 const GLchar* selected_string; 3068 3069 if (DOS == m_test_case.m_line_endings) 3070 { 3071 selected_string = line_continuation_ending_dos; 3072 } 3073 else 3074 { 3075 selected_string = line_continuation_ending_unix; 3076 } 3077 3078 GLuint n_repetitions = (ONCE == m_test_case.m_repetitions) ? 1 : m_n_repetitions; 3079 3080 for (GLuint i = 0; i < n_repetitions; ++i) 3081 { 3082 result.append(selected_string); 3083 } 3084 3085 return result; 3086 } 3087 3088 /** Decides if shader should consist of multiple parts for the current test case 3089 * 3090 * @return true if test case requires multiple parts, false otherwise 3091 **/ 3092 bool LineContinuationTest::isShaderMultipart() const 3093 { 3094 bool result; 3095 3096 switch (m_test_case.m_case) 3097 { 3098 case ASSIGNMENT_BEFORE_OPERATOR: 3099 case ASSIGNMENT_AFTER_OPERATOR: 3100 case VECTOR_VARIABLE_INITIALIZER: 3101 case TOKEN_INSIDE_FUNCTION_NAME: 3102 case TOKEN_INSIDE_TYPE_NAME: 3103 case TOKEN_INSIDE_VARIABLE_NAME: 3104 case PREPROCESSOR_TOKEN_INSIDE: 3105 case PREPROCESSOR_TOKEN_BETWEEN: 3106 case COMMENT: 3107 case SOURCE_TERMINATION_NULL: 3108 case SOURCE_TERMINATION_NON_NULL: 3109 default: 3110 result = false; 3111 break; 3112 case PART_TERMINATION_NULL: 3113 case PART_NEXT_TO_TERMINATION_NULL: 3114 case PART_TERMINATION_NON_NULL: 3115 case PART_NEXT_TO_TERMINATION_NON_NULL: 3116 result = true; 3117 break; 3118 }; 3119 3120 return result; 3121 } 3122 3123 /** String describing line endings 3124 * 3125 * @param line_ending Line ending enum 3126 * 3127 * @return "unix" or "dos" strings 3128 **/ 3129 const GLchar* LineContinuationTest::lineEndingsToStr(LINE_ENDINGS line_ending) const 3130 { 3131 const GLchar* result = 0; 3132 3133 if (UNIX == line_ending) 3134 { 3135 result = "unix"; 3136 } 3137 else 3138 { 3139 result = "dos"; 3140 } 3141 3142 return result; 3143 } 3144 3145 /** String describing number of repetitions 3146 * 3147 * @param repetitions Repetitions enum 3148 * 3149 * @return "single" or "multiple" strings 3150 **/ 3151 const GLchar* LineContinuationTest::repetitionsToStr(REPETITIONS repetitions) const 3152 { 3153 const GLchar* result = 0; 3154 3155 if (ONCE == repetitions) 3156 { 3157 result = "single"; 3158 } 3159 else 3160 { 3161 result = "multiple"; 3162 } 3163 3164 return result; 3165 } 3166 3167 /** Replace all CASES tokens 3168 * 3169 * @param source String with shader template 3170 **/ 3171 void LineContinuationTest::replaceAllCaseTokens(std::string& source) const 3172 { 3173 3174 /* Tokens to be replaced with line continuation */ 3175 static const GLchar* token_assignment_before_operator_case = "ASSIGNMENT_BEFORE_OPERATOR_CASE"; 3176 static const GLchar* token_assignment_after_operator_case = "ASSIGNMENT_AFTER_OPERATOR_CASE"; 3177 static const GLchar* token_vector_initializer = "VECTOR_VARIABLE_INITIALIZER_CASE"; 3178 static const GLchar* token_function_case = "FUNCTION_CASE"; 3179 static const GLchar* token_type_case = "TYPE_CASE"; 3180 static const GLchar* token_variable_case = "VARIABLE_CASE"; 3181 static const GLchar* token_preprocessor_inside_case = "PREPROCESSOR_INSIDE_CASE"; 3182 static const GLchar* token_preprocessor_between_case = "PREPROCESSOR_BETWEEN_CASE"; 3183 static const GLchar* token_comment = "COMMENT_CASE"; 3184 static const GLchar* token_termination = "TERMINATION_CASE"; 3185 static const GLchar* token_next_to_termination = "NEXT_TO_TERMINATION_CASE"; 3186 3187 /* Line continuation and empty string*/ 3188 static const GLchar* empty = ""; 3189 const std::string& line_continuation = getLineContinuationString(); 3190 3191 /* These strings will used to replace "CASE" tokens */ 3192 const GLchar* assignment_before_operator_case = empty; 3193 const GLchar* assignment_after_operator_case = empty; 3194 const GLchar* vector_variable_initializer_case = empty; 3195 const GLchar* function_case = empty; 3196 const GLchar* type_case = empty; 3197 const GLchar* variable_case = empty; 3198 const GLchar* preprocessor_inside_case = empty; 3199 const GLchar* preprocessor_between_case = empty; 3200 const GLchar* comment_case = empty; 3201 const GLchar* source_termination_case = empty; 3202 const GLchar* part_termination_case = empty; 3203 const GLchar* next_to_part_termination_case = empty; 3204 3205 /* Configuration of test case */ 3206 switch (m_test_case.m_case) 3207 { 3208 case ASSIGNMENT_BEFORE_OPERATOR: 3209 assignment_before_operator_case = line_continuation.c_str(); 3210 break; 3211 case ASSIGNMENT_AFTER_OPERATOR: 3212 assignment_after_operator_case = line_continuation.c_str(); 3213 break; 3214 case VECTOR_VARIABLE_INITIALIZER: 3215 vector_variable_initializer_case = line_continuation.c_str(); 3216 break; 3217 case TOKEN_INSIDE_FUNCTION_NAME: 3218 function_case = line_continuation.c_str(); 3219 break; 3220 case TOKEN_INSIDE_TYPE_NAME: 3221 type_case = line_continuation.c_str(); 3222 break; 3223 case TOKEN_INSIDE_VARIABLE_NAME: 3224 variable_case = line_continuation.c_str(); 3225 break; 3226 case PREPROCESSOR_TOKEN_INSIDE: 3227 preprocessor_inside_case = line_continuation.c_str(); 3228 break; 3229 case PREPROCESSOR_TOKEN_BETWEEN: 3230 preprocessor_between_case = line_continuation.c_str(); 3231 break; 3232 case COMMENT: 3233 comment_case = line_continuation.c_str(); 3234 break; 3235 case SOURCE_TERMINATION_NULL: /* intended fall through */ 3236 case SOURCE_TERMINATION_NON_NULL: 3237 source_termination_case = line_continuation.c_str(); 3238 break; 3239 case PART_TERMINATION_NULL: /* intended fall through */ 3240 case PART_TERMINATION_NON_NULL: 3241 part_termination_case = line_continuation.c_str(); 3242 source_termination_case = line_continuation.c_str(); 3243 break; 3244 case PART_NEXT_TO_TERMINATION_NULL: /* intended fall through */ 3245 case PART_NEXT_TO_TERMINATION_NON_NULL: 3246 next_to_part_termination_case = line_continuation.c_str(); 3247 break; 3248 case DEBUG_CASE: /* intended fall through */ 3249 default: 3250 break; /* no line continuations */ 3251 }; 3252 3253 Utils::replaceAllTokens(token_assignment_after_operator_case, assignment_after_operator_case, source); 3254 Utils::replaceAllTokens(token_assignment_before_operator_case, assignment_before_operator_case, source); 3255 Utils::replaceAllTokens(token_comment, comment_case, source); 3256 Utils::replaceAllTokens(token_function_case, function_case, source); 3257 Utils::replaceAllTokens(token_next_to_termination, next_to_part_termination_case, source); 3258 Utils::replaceAllTokens(token_termination, part_termination_case, source); 3259 Utils::replaceAllTokens(token_preprocessor_between_case, preprocessor_between_case, source); 3260 Utils::replaceAllTokens(token_preprocessor_inside_case, preprocessor_inside_case, source); 3261 Utils::replaceAllTokens(token_termination, source_termination_case, source); 3262 Utils::replaceAllTokens(token_type_case, type_case, source); 3263 Utils::replaceAllTokens(token_variable_case, variable_case, source); 3264 Utils::replaceAllTokens(token_vector_initializer, vector_variable_initializer_case, source); 3265 } 3266 3267 /** Decides if the current test case requires source lengths 3268 * 3269 * @return true if test requires lengths, false otherwise 3270 **/ 3271 bool LineContinuationTest::useSourceLengths() const 3272 { 3273 bool result; 3274 3275 switch (m_test_case.m_case) 3276 { 3277 case ASSIGNMENT_BEFORE_OPERATOR: 3278 case ASSIGNMENT_AFTER_OPERATOR: 3279 case VECTOR_VARIABLE_INITIALIZER: 3280 case TOKEN_INSIDE_FUNCTION_NAME: 3281 case TOKEN_INSIDE_TYPE_NAME: 3282 case TOKEN_INSIDE_VARIABLE_NAME: 3283 case PREPROCESSOR_TOKEN_INSIDE: 3284 case PREPROCESSOR_TOKEN_BETWEEN: 3285 case COMMENT: 3286 case SOURCE_TERMINATION_NULL: 3287 case PART_TERMINATION_NULL: 3288 case PART_NEXT_TO_TERMINATION_NULL: 3289 default: 3290 result = false; 3291 break; 3292 case SOURCE_TERMINATION_NON_NULL: 3293 case PART_TERMINATION_NON_NULL: 3294 case PART_NEXT_TO_TERMINATION_NON_NULL: 3295 result = true; 3296 break; 3297 }; 3298 3299 return result; 3300 } 3301 3302 /** Constructor 3303 * 3304 * @param context Test context 3305 **/ 3306 LineNumberingTest::LineNumberingTest(deqp::Context& context) 3307 : GLSLTestBase(context, "line_numbering", "Verify if line numbering is correct after line continuation") 3308 { 3309 /* Nothing to be done here */ 3310 } 3311 3312 /** Prepare source for given shader stage 3313 * 3314 * @param in_stage Shader stage, compute shader will use 430 3315 * @param in_use_version_400 Select if 400 or 420 should be used 3316 * @param out_source Prepared shader source instance 3317 **/ 3318 void LineNumberingTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 3319 Utils::shaderSource& out_source) 3320 { 3321 static const GLchar* test_result_snippet_normal[6] = { /* Utils::COMPUTE_SHADER */ 3322 "ivec4(11, 1, 2, 3)", 3323 /* Utils::VERTEX_SHADER */ 3324 "ivec4(9, 1, 2, 3)", 3325 /* Utils::TESS_CTRL_SHADER */ 3326 "ivec4(12, 1, 2, 3)", 3327 /* Utils::TESS_EVAL_SHADER */ 3328 "ivec4(12, 1, 2, 3)", 3329 /* Utils::GEOMETRY_SHADER */ 3330 "ivec4(13, 1, 2, 3)", 3331 /* Utils::FRAGMENT_SHADER */ 3332 "ivec4(10, 1, 2, 3)" 3333 }; 3334 3335 static const GLchar* test_result_snippet_400[6] = { /* Utils::COMPUTE_SHADER */ 3336 "ivec4(13, 1, 2, 3)", 3337 /* Utils::VERTEX_SHADER */ 3338 "ivec4(11, 1, 2, 3)", 3339 /* Utils::TESS_CTRL_SHADER */ 3340 "ivec4(14, 1, 2, 3)", 3341 /* Utils::TESS_EVAL_SHADER */ 3342 "ivec4(14, 1, 2, 3)", 3343 /* Utils::GEOMETRY_SHADER */ 3344 "ivec4(15, 1, 2, 3)", 3345 /* Utils::FRAGMENT_SHADER */ 3346 "ivec4(12, 1, 2, 3)" 3347 }; 3348 3349 static const GLchar* line_numbering_snippet = "ivec4 glsl\\\n" 3350 "Test\\\n" 3351 "Function(in ivec3 arg)\n" 3352 "{\n" 3353 " return ivec4(__LINE__, arg.xyz);\n" 3354 "}\n"; 3355 3356 static const GLchar* compute_shader_template = 3357 "VERSION\n" 3358 "\n" 3359 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 3360 "\n" 3361 "writeonly uniform image2D uni_image;\n" 3362 "\n" 3363 "GLSL_TEST_FUNCTION" 3364 "\n" 3365 "void main()\n" 3366 "{\n" 3367 " vec4 result = vec4(1, 0, 0, 1);\n" 3368 "\n" 3369 " if (GLSL_TEST_RESULT == glslTestFunction(ivec3(1, 2, 3)))\n" 3370 " {\n" 3371 " result = vec4(0, 1, 0, 1);\n" 3372 " }\n" 3373 "\n" 3374 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 3375 "}\n" 3376 "\n"; 3377 3378 static const GLchar* fragment_shader_template = 3379 "VERSION\n" 3380 "\n" 3381 "in vec4 gs_fs_result;\n" 3382 "out vec4 fs_out_result;\n" 3383 "\n" 3384 "GLSL_TEST_FUNCTION" 3385 "\n" 3386 "void main()\n" 3387 "{\n" 3388 " vec4 result = vec4(1, 0, 0, 1);\n" 3389 "\n" 3390 " if ((GLSL_TEST_RESULT == glslTestFunction(ivec3(1, 2, 3))) &&\n" 3391 " (vec4(0, 1, 0, 1) == gs_fs_result) )\n" 3392 " {\n" 3393 " result = vec4(0, 1, 0, 1);\n" 3394 " }\n" 3395 "\n" 3396 " fs_out_result = result;\n" 3397 "}\n" 3398 "\n"; 3399 3400 static const GLchar* geometry_shader_template = 3401 "VERSION\n" 3402 "\n" 3403 "layout(points) in;\n" 3404 "layout(triangle_strip, max_vertices = 4) out;\n" 3405 "\n" 3406 "in vec4 tes_gs_result[];\n" 3407 "out vec4 gs_fs_result;\n" 3408 "\n" 3409 "GLSL_TEST_FUNCTION" 3410 "\n" 3411 "void main()\n" 3412 "{\n" 3413 " vec4 result = vec4(1, 0, 0, 1);\n" 3414 "\n" 3415 " if ((GLSL_TEST_RESULT == glslTestFunction(ivec3(1, 2, 3))) &&\n" 3416 " (vec4(0, 1, 0, 1) == tes_gs_result[0]) )\n" 3417 " {\n" 3418 " result = vec4(0, 1, 0, 1);\n" 3419 " }\n" 3420 "\n" 3421 " gs_fs_result = result;\n" 3422 " gl_Position = vec4(-1, -1, 0, 1);\n" 3423 " EmitVertex();\n" 3424 " gs_fs_result = result;\n" 3425 " gl_Position = vec4(-1, 1, 0, 1);\n" 3426 " EmitVertex();\n" 3427 " gs_fs_result = result;\n" 3428 " gl_Position = vec4(1, -1, 0, 1);\n" 3429 " EmitVertex();\n" 3430 " gs_fs_result = result;\n" 3431 " gl_Position = vec4(1, 1, 0, 1);\n" 3432 " EmitVertex();\n" 3433 "}\n" 3434 "\n"; 3435 3436 static const GLchar* tess_ctrl_shader_template = 3437 "VERSION\n" 3438 "\n" 3439 "layout(vertices = 1) out;\n" 3440 "\n" 3441 "in vec4 vs_tcs_result[];\n" 3442 "out vec4 tcs_tes_result[];\n" 3443 "\n" 3444 "GLSL_TEST_FUNCTION" 3445 "\n" 3446 "void main()\n" 3447 "{\n" 3448 " vec4 result = vec4(1, 0, 0, 1);\n" 3449 "\n" 3450 " if ((GLSL_TEST_RESULT == glslTestFunction(ivec3(1, 2, 3))) &&\n" 3451 " (vec4(0, 1, 0, 1) == vs_tcs_result[gl_InvocationID]) )\n" 3452 " {\n" 3453 " result = vec4(0, 1, 0, 1);\n" 3454 " }\n" 3455 "\n" 3456 " tcs_tes_result[gl_InvocationID] = result;\n" 3457 "\n" 3458 " gl_TessLevelOuter[0] = 1.0;\n" 3459 " gl_TessLevelOuter[1] = 1.0;\n" 3460 " gl_TessLevelOuter[2] = 1.0;\n" 3461 " gl_TessLevelOuter[3] = 1.0;\n" 3462 " gl_TessLevelInner[0] = 1.0;\n" 3463 " gl_TessLevelInner[1] = 1.0;\n" 3464 "}\n" 3465 "\n"; 3466 3467 static const GLchar* tess_eval_shader_template = 3468 "VERSION\n" 3469 "\n" 3470 "layout(isolines, point_mode) in;\n" 3471 "\n" 3472 "in vec4 tcs_tes_result[];\n" 3473 "out vec4 tes_gs_result;\n" 3474 "\n" 3475 "GLSL_TEST_FUNCTION" 3476 "\n" 3477 "void main()\n" 3478 "{\n" 3479 " vec4 result = vec4(1, 0, 0, 1);\n" 3480 "\n" 3481 " if ((GLSL_TEST_RESULT == glslTestFunction(ivec3(1, 2, 3))) &&\n" 3482 " (vec4(0, 1, 0, 1) == tcs_tes_result[0]) )\n" 3483 " {\n" 3484 " result = vec4(0, 1, 0, 1);\n" 3485 " }\n" 3486 "\n" 3487 " tes_gs_result = result;\n" 3488 "}\n" 3489 "\n"; 3490 3491 static const GLchar* vertex_shader_template = "VERSION\n" 3492 "\n" 3493 "out vec4 vs_tcs_result;\n" 3494 "\n" 3495 "GLSL_TEST_FUNCTION" 3496 "\n" 3497 "void main()\n" 3498 "{\n" 3499 " vec4 result = vec4(1, 0, 0, 1);\n" 3500 "\n" 3501 " if (GLSL_TEST_RESULT == glslTestFunction(ivec3(1, 2, 3)))\n" 3502 " {\n" 3503 " result = vec4(0, 1, 0, 1);\n" 3504 " }\n" 3505 "\n" 3506 " vs_tcs_result = result;\n" 3507 "}\n" 3508 "\n"; 3509 3510 const GLchar* shader_template = 0; 3511 3512 switch (in_stage) 3513 { 3514 case Utils::COMPUTE_SHADER: 3515 shader_template = compute_shader_template; 3516 break; 3517 case Utils::FRAGMENT_SHADER: 3518 shader_template = fragment_shader_template; 3519 break; 3520 case Utils::GEOMETRY_SHADER: 3521 shader_template = geometry_shader_template; 3522 break; 3523 case Utils::TESS_CTRL_SHADER: 3524 shader_template = tess_ctrl_shader_template; 3525 break; 3526 case Utils::TESS_EVAL_SHADER: 3527 shader_template = tess_eval_shader_template; 3528 break; 3529 case Utils::VERTEX_SHADER: 3530 shader_template = vertex_shader_template; 3531 break; 3532 default: 3533 TCU_FAIL("Invalid enum"); 3534 break; 3535 } 3536 3537 out_source.m_parts[0].m_code = shader_template; 3538 3539 size_t position = 0; 3540 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 3541 out_source.m_parts[0].m_code); 3542 3543 Utils::replaceToken("GLSL_TEST_FUNCTION", position, line_numbering_snippet, out_source.m_parts[0].m_code); 3544 3545 Utils::replaceToken("GLSL_TEST_RESULT", position, 3546 in_use_version_400 ? test_result_snippet_400[in_stage] : test_result_snippet_normal[in_stage], 3547 out_source.m_parts[0].m_code); 3548 } 3549 3550 /** Constructor 3551 * 3552 * @param context Test context 3553 **/ 3554 UTF8CharactersTest::UTF8CharactersTest(deqp::Context& context) 3555 : GLSLTestBase(context, "utf8_characters", "UTF8 character used in comment or preprocessor") 3556 { 3557 /* Nothing to be done here */ 3558 } 3559 3560 /** Overwrite getShaderSourceConfig method 3561 * 3562 * @param out_n_parts Number of source parts used by this test case 3563 * @param out_use_lengths If source lengths shall be provided to compiler 3564 **/ 3565 void UTF8CharactersTest::getShaderSourceConfig(GLuint& out_n_parts, bool& out_use_lengths) 3566 { 3567 out_n_parts = 1; 3568 out_use_lengths = (AS_LAST_CHARACTER_NON_NULL_TERMINATED == m_test_case.m_case) ? true : false; 3569 } 3570 3571 /** Set up next test case 3572 * 3573 * @param test_case_index Index of next test case 3574 * 3575 * @return false if there is no more test cases, true otherwise 3576 **/ 3577 bool UTF8CharactersTest::prepareNextTestCase(glw::GLuint test_case_index) 3578 { 3579 static const testCase test_cases[] = { 3580 { IN_COMMENT, Utils::TWO_BYTES }, 3581 { IN_COMMENT, Utils::THREE_BYTES }, 3582 { IN_COMMENT, Utils::FOUR_BYTES }, 3583 { IN_COMMENT, Utils::FIVE_BYTES }, 3584 { IN_COMMENT, Utils::SIX_BYTES }, 3585 { IN_COMMENT, Utils::REDUNDANT_ASCII }, 3586 { IN_PREPROCESSOR, Utils::TWO_BYTES }, 3587 { IN_PREPROCESSOR, Utils::THREE_BYTES }, 3588 { IN_PREPROCESSOR, Utils::FOUR_BYTES }, 3589 { IN_PREPROCESSOR, Utils::FIVE_BYTES }, 3590 { IN_PREPROCESSOR, Utils::SIX_BYTES }, 3591 { IN_PREPROCESSOR, Utils::REDUNDANT_ASCII }, 3592 { AS_LAST_CHARACTER_NULL_TERMINATED, Utils::TWO_BYTES }, 3593 { AS_LAST_CHARACTER_NULL_TERMINATED, Utils::THREE_BYTES }, 3594 { AS_LAST_CHARACTER_NULL_TERMINATED, Utils::FOUR_BYTES }, 3595 { AS_LAST_CHARACTER_NULL_TERMINATED, Utils::FIVE_BYTES }, 3596 { AS_LAST_CHARACTER_NULL_TERMINATED, Utils::SIX_BYTES }, 3597 { AS_LAST_CHARACTER_NULL_TERMINATED, Utils::REDUNDANT_ASCII }, 3598 { AS_LAST_CHARACTER_NON_NULL_TERMINATED, Utils::TWO_BYTES }, 3599 { AS_LAST_CHARACTER_NON_NULL_TERMINATED, Utils::THREE_BYTES }, 3600 { AS_LAST_CHARACTER_NON_NULL_TERMINATED, Utils::FOUR_BYTES }, 3601 { AS_LAST_CHARACTER_NON_NULL_TERMINATED, Utils::FIVE_BYTES }, 3602 { AS_LAST_CHARACTER_NON_NULL_TERMINATED, Utils::SIX_BYTES }, 3603 { AS_LAST_CHARACTER_NON_NULL_TERMINATED, Utils::REDUNDANT_ASCII }, 3604 }; 3605 3606 static const GLuint max_test_cases = sizeof(test_cases) / sizeof(testCase); 3607 3608 if ((GLuint)-1 == test_case_index) 3609 { 3610 m_test_case.m_case = DEBUG_CASE; 3611 m_test_case.m_character = Utils::EMPTY; 3612 } 3613 else if (max_test_cases <= test_case_index) 3614 { 3615 return false; 3616 } 3617 else 3618 { 3619 m_test_case = test_cases[test_case_index]; 3620 } 3621 3622 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Test case: utf8 character: " 3623 << Utils::getUtf8Character(m_test_case.m_character) << " is placed " 3624 << casesToStr() << tcu::TestLog::EndMessage; 3625 3626 return true; 3627 } 3628 3629 /** Prepare source for given shader stage 3630 * 3631 * @param in_stage Shader stage, compute shader will use 430 3632 * @param in_use_version_400 Select if 400 or 420 should be used 3633 * @param out_source Prepared shader source instance 3634 **/ 3635 void UTF8CharactersTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 3636 Utils::shaderSource& out_source) 3637 { 3638 static const GLchar* compute_shader_template = 3639 "VERSION\n" 3640 "\n" 3641 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 3642 "\n" 3643 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 3644 "\n" 3645 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 3646 "\n" 3647 "writeonly uniform image2D uni_image;\n" 3648 " uniform sampler2D uni_sampler;\n" 3649 "\n" 3650 "#if 0\n" 3651 " #define SET_REPREPROCESSOR_CASESULT(XX) result = XX\n" 3652 "#else\n" 3653 " #define SET_RESULT(XX) result = XX\n" 3654 "#endif\n" 3655 "\n" 3656 "void main()\n" 3657 "{\n" 3658 " ivec2 coordinates = ivec2(gl_GlobalInvocationID.xy + ivec2(16, 16));\n" 3659 " vec4 result = vec4(1, 0, 0, 1);\n" 3660 "\n" 3661 " if (vec4(0, 0, 1, 1) == texelFetch(uni_sampler, coordinates, 0 /* lod */))\n" 3662 " {\n" 3663 " SET_RESULT(vec4(0, 1, 0, 1));\n" 3664 " }\n" 3665 "\n" 3666 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 3667 "}\n" 3668 "// Lorem ipsum LAST_CHARACTER_CASE"; 3669 3670 static const GLchar* fragment_shader_template = 3671 "VERSION\n" 3672 "\n" 3673 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 3674 "\n" 3675 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 3676 "\n" 3677 "in vec4 gs_fs_result;\n" 3678 "in vec2 gs_fs_tex_coord;\n" 3679 "out vec4 fs_out_result;\n" 3680 "uniform sampler2D uni_sampler;\n" 3681 "\n" 3682 "#if 0\n" 3683 " #define SET_REPREPROCESSOR_CASESULT(XX) result = XX\n" 3684 "#else\n" 3685 " #define SET_RESULT(XX) result = XX\n" 3686 "#endif\n" 3687 "\n" 3688 "void main()\n" 3689 "{\n" 3690 " vec4 result = vec4(1, 0, 0, 1);\n" 3691 "\n" 3692 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, gs_fs_tex_coord)) &&\n" 3693 " (vec4(0, 1, 0, 1) == gs_fs_result) )\n" 3694 " {\n" 3695 " SET_RESULT(vec4(0, 1, 0, 1));\n" 3696 " }\n" 3697 "\n" 3698 " fs_out_result = result;\n" 3699 "}\n" 3700 "// Lorem ipsum LAST_CHARACTER_CASE"; 3701 3702 static const GLchar* geometry_shader_template = 3703 "VERSION\n" 3704 "\n" 3705 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 3706 "\n" 3707 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 3708 "\n" 3709 "layout(points) in;\n" 3710 "layout(triangle_strip, max_vertices = 4) out;\n" 3711 "\n" 3712 "in vec4 tes_gs_result[];\n" 3713 "out vec2 gs_fs_tex_coord;\n" 3714 "out vec4 gs_fs_result;\n" 3715 "uniform sampler2D uni_sampler;\n" 3716 "\n" 3717 "#if 0\n" 3718 " #define SET_REPREPROCESSOR_CASESULT(XX) result = XX\n" 3719 "#else\n" 3720 " #define SET_RESULT(XX) result = XX\n" 3721 "#endif\n" 3722 "\n" 3723 "void main()\n" 3724 "{\n" 3725 " vec4 result = vec4(1, 0, 0, 1);\n" 3726 "\n" 3727 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.5, 0.5))) &&\n" 3728 " (vec4(0, 1, 0, 1) == tes_gs_result[0]) )\n" 3729 " {\n" 3730 " SET_RESULT(vec4(0, 1, 0, 1));\n" 3731 " }\n" 3732 "\n" 3733 " gs_fs_tex_coord = vec2(0.25, 0.25);\n" 3734 " gs_fs_result = result;\n" 3735 " gl_Position = vec4(-1, -1, 0, 1);\n" 3736 " EmitVertex();\n" 3737 " gs_fs_tex_coord = vec2(0.25, 0.75);\n" 3738 " gs_fs_result = result;\n" 3739 " gl_Position = vec4(-1, 1, 0, 1);\n" 3740 " EmitVertex();\n" 3741 " gs_fs_tex_coord = vec2(0.75, 0.25);\n" 3742 " gs_fs_result = result;\n" 3743 " gl_Position = vec4(1, -1, 0, 1);\n" 3744 " EmitVertex();\n" 3745 " gs_fs_tex_coord = vec2(0.75, 0.75);\n" 3746 " gs_fs_result = result;\n" 3747 " gl_Position = vec4(1, 1, 0, 1);\n" 3748 " EmitVertex();\n" 3749 "}\n" 3750 "// Lorem ipsum LAST_CHARACTER_CASE"; 3751 3752 static const GLchar* tess_ctrl_shader_template = 3753 "VERSION\n" 3754 "\n" 3755 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 3756 "\n" 3757 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 3758 "\n" 3759 "layout(vertices = 1) out;\n" 3760 "\n" 3761 "in vec4 vs_tcs_result[];\n" 3762 "out vec4 tcs_tes_result[];\n" 3763 "uniform sampler2D uni_sampler;\n" 3764 "\n" 3765 "#if 0\n" 3766 " #define SET_REPREPROCESSOR_CASESULT(XX) result = XX\n" 3767 "#else\n" 3768 " #define SET_RESULT(XX) result = XX\n" 3769 "#endif\n" 3770 "\n" 3771 "void main()\n" 3772 "{\n" 3773 " vec4 result = vec4(1, 0, 0, 1);\n" 3774 "\n" 3775 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.4, 0.4))) &&\n" 3776 " (vec4(0, 1, 0, 1) == vs_tcs_result[gl_InvocationID]) )\n" 3777 " {\n" 3778 " SET_RESULT(vec4(0, 1, 0, 1));\n" 3779 " }\n" 3780 "\n" 3781 " tcs_tes_result[gl_InvocationID] = result;\n" 3782 "\n" 3783 " gl_TessLevelOuter[0] = 1.0;\n" 3784 " gl_TessLevelOuter[1] = 1.0;\n" 3785 " gl_TessLevelOuter[2] = 1.0;\n" 3786 " gl_TessLevelOuter[3] = 1.0;\n" 3787 " gl_TessLevelInner[0] = 1.0;\n" 3788 " gl_TessLevelInner[1] = 1.0;\n" 3789 "}\n" 3790 "// Lorem ipsum LAST_CHARACTER_CASE"; 3791 3792 static const GLchar* tess_eval_shader_template = 3793 "VERSION\n" 3794 "\n" 3795 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 3796 "\n" 3797 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 3798 "\n" 3799 "layout(isolines, point_mode) in;\n" 3800 "\n" 3801 "in vec4 tcs_tes_result[];\n" 3802 "out vec4 tes_gs_result;\n" 3803 "uniform sampler2D uni_sampler;\n" 3804 "\n" 3805 "#if 0\n" 3806 " #define SET_REPREPROCESSOR_CASESULT(XX) result = XX\n" 3807 "#else\n" 3808 " #define SET_RESULT(XX) result = XX\n" 3809 "#endif\n" 3810 "\n" 3811 "void main()\n" 3812 "{\n" 3813 " vec4 result = vec4(1, 0, 0, 1);\n" 3814 "\n" 3815 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.6, 0.6))) &&\n" 3816 " (vec4(0, 1, 0, 1) == tcs_tes_result[0]) )\n" 3817 " {\n" 3818 " SET_RESULT(vec4(0, 1, 0, 1));\n" 3819 " }\n" 3820 "\n" 3821 " tes_gs_result = result;\n" 3822 "}\n" 3823 "// Lorem ipsum LAST_CHARACTER_CASE"; 3824 3825 static const GLchar* vertex_shader_template = 3826 "VERSION\n" 3827 "\n" 3828 "// Lorem ipsum dolor sit amCOMMENT_CASEet, consectetur adipiscing elit posuere.\n" 3829 "\n" 3830 "/* Lorem ipsum dolor sit amet, conCOMMENT_CASEsectetur adipiscing elit posuere. */\n" 3831 "\n" 3832 "out vec4 vs_tcs_result;\n" 3833 "uniform sampler2D uni_sampler;\n" 3834 "\n" 3835 "#if 0\n" 3836 " #define SET_REPREPROCESSOR_CASESULT(XX) result = XX\n" 3837 "#else\n" 3838 " #define SET_RESULT(XX) result = XX\n" 3839 "#endif\n" 3840 "\n" 3841 "void main()\n" 3842 "{\n" 3843 " vec4 result = vec4(1, 0, 0, 1);\n" 3844 "\n" 3845 " if (vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.5, 0.5)) )\n" 3846 " {\n" 3847 " SET_RESULT(vec4(0, 1, 0, 1));\n" 3848 " }\n" 3849 "\n" 3850 " vs_tcs_result = result;\n" 3851 "}\n" 3852 "// Lorem ipsum LAST_CHARACTER_CASE"; 3853 3854 const GLchar* shader_template = 0; 3855 const GLchar* comment_case = ""; 3856 const GLchar* preprocessor_case = ""; 3857 const GLchar* last_character_case = ""; 3858 const GLchar* utf8_character = Utils::getUtf8Character(m_test_case.m_character); 3859 3860 switch (in_stage) 3861 { 3862 case Utils::COMPUTE_SHADER: 3863 shader_template = compute_shader_template; 3864 break; 3865 case Utils::FRAGMENT_SHADER: 3866 shader_template = fragment_shader_template; 3867 break; 3868 case Utils::GEOMETRY_SHADER: 3869 shader_template = geometry_shader_template; 3870 break; 3871 case Utils::TESS_CTRL_SHADER: 3872 shader_template = tess_ctrl_shader_template; 3873 break; 3874 case Utils::TESS_EVAL_SHADER: 3875 shader_template = tess_eval_shader_template; 3876 break; 3877 case Utils::VERTEX_SHADER: 3878 shader_template = vertex_shader_template; 3879 break; 3880 default: 3881 TCU_FAIL("Invalid enum"); 3882 break; 3883 } 3884 3885 switch (m_test_case.m_case) 3886 { 3887 case IN_COMMENT: 3888 comment_case = utf8_character; 3889 break; 3890 case IN_PREPROCESSOR: 3891 preprocessor_case = utf8_character; 3892 break; 3893 case AS_LAST_CHARACTER_NULL_TERMINATED: 3894 last_character_case = utf8_character; 3895 break; 3896 case AS_LAST_CHARACTER_NON_NULL_TERMINATED: 3897 last_character_case = utf8_character; 3898 break; 3899 case DEBUG_CASE: 3900 break; 3901 default: 3902 TCU_FAIL("Invalid enum"); 3903 } 3904 3905 out_source.m_parts[0].m_code = shader_template; 3906 3907 size_t position = 0; 3908 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 3909 out_source.m_parts[0].m_code); 3910 3911 Utils::replaceAllTokens("COMMENT_CASE", comment_case, out_source.m_parts[0].m_code); 3912 3913 Utils::replaceAllTokens("PREPROCESSOR_CASE", preprocessor_case, out_source.m_parts[0].m_code); 3914 3915 Utils::replaceAllTokens("LAST_CHARACTER_CASE", last_character_case, out_source.m_parts[0].m_code); 3916 } 3917 3918 /** Prepare texture 3919 * 3920 * @param texture Texutre to be created and filled with content 3921 * 3922 * @return Name of sampler uniform that should be used for the texture 3923 **/ 3924 const GLchar* UTF8CharactersTest::prepareSourceTexture(Utils::texture& texture) 3925 { 3926 std::vector<GLuint> data; 3927 static const GLuint width = 64; 3928 static const GLuint height = 64; 3929 static const GLuint data_size = width * height; 3930 static const GLuint blue_color = 0xffff0000; 3931 static const GLuint grey_color = 0xaaaaaaaa; 3932 3933 data.resize(data_size); 3934 3935 for (GLuint i = 0; i < data_size; ++i) 3936 { 3937 data[i] = grey_color; 3938 } 3939 3940 for (GLuint y = 16; y < 48; ++y) 3941 { 3942 const GLuint line_offset = y * 64; 3943 3944 for (GLuint x = 16; x < 48; ++x) 3945 { 3946 const GLuint pixel_offset = x + line_offset; 3947 3948 data[pixel_offset] = blue_color; 3949 } 3950 } 3951 3952 texture.create(width, height, GL_RGBA8); 3953 3954 texture.update(width, height, 0 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]); 3955 3956 return "uni_sampler"; 3957 } 3958 3959 /** Returns description of current test case 3960 * 3961 * @return String with description 3962 **/ 3963 const GLchar* UTF8CharactersTest::casesToStr() const 3964 { 3965 const GLchar* result = 0; 3966 3967 switch (m_test_case.m_case) 3968 { 3969 case IN_COMMENT: 3970 result = "in comment"; 3971 break; 3972 case IN_PREPROCESSOR: 3973 result = "in preprocessor"; 3974 break; 3975 case AS_LAST_CHARACTER_NULL_TERMINATED: 3976 result = "just before null"; 3977 break; 3978 case AS_LAST_CHARACTER_NON_NULL_TERMINATED: 3979 result = "as last character"; 3980 break; 3981 case DEBUG_CASE: 3982 result = "nowhere. This is debug!"; 3983 break; 3984 default: 3985 TCU_FAIL("Invalid enum"); 3986 } 3987 3988 return result; 3989 } 3990 3991 /** Constructor 3992 * 3993 * @param context Test context 3994 **/ 3995 UTF8InSourceTest::UTF8InSourceTest(deqp::Context& context) 3996 : NegativeTestBase(context, "utf8_in_source", "UTF8 characters used in shader source") 3997 { 3998 /* Nothing to be done here */ 3999 } 4000 4001 /** Set up next test case 4002 * 4003 * @param test_case_index Index of next test case 4004 * 4005 * @return false if there is no more test cases, true otherwise 4006 **/ 4007 bool UTF8InSourceTest::prepareNextTestCase(glw::GLuint test_case_index) 4008 { 4009 static const Utils::UTF8_CHARACTERS test_cases[] = { 4010 Utils::TWO_BYTES, Utils::THREE_BYTES, Utils::FOUR_BYTES, 4011 Utils::FIVE_BYTES, Utils::SIX_BYTES, Utils::REDUNDANT_ASCII 4012 }; 4013 4014 static const GLuint max_test_cases = sizeof(test_cases) / sizeof(Utils::UTF8_CHARACTERS); 4015 4016 if ((GLuint)-1 == test_case_index) 4017 { 4018 m_character = Utils::EMPTY; 4019 } 4020 else if (max_test_cases <= test_case_index) 4021 { 4022 return false; 4023 } 4024 else 4025 { 4026 m_character = test_cases[test_case_index]; 4027 } 4028 4029 m_context.getTestContext().getLog() << tcu::TestLog::Message 4030 << "Test case: utf8 character: " << Utils::getUtf8Character(m_character) 4031 << tcu::TestLog::EndMessage; 4032 4033 return true; 4034 } 4035 4036 /** Prepare source for given shader stage 4037 * 4038 * @param in_stage Shader stage, compute shader will use 430 4039 * @param in_use_version_400 Select if 400 or 420 should be used 4040 * @param out_source Prepared shader source instance 4041 **/ 4042 void UTF8InSourceTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 4043 Utils::shaderSource& out_source) 4044 { 4045 static const GLchar* compute_shader_template = 4046 "VERSION\n" 4047 "\n" 4048 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 4049 "\n" 4050 "writeonly uniform image2D uni_image;\n" 4051 " uniform sampler2D uni_sampler;\n" 4052 "\n" 4053 "#define SET_RESULT(XX) resHEREult = XX\n" 4054 "\n" 4055 "void main()\n" 4056 "{\n" 4057 " ivec2 coordinates = ivec2(gl_GlobalInvocationID.xy + ivec2(16, 16));\n" 4058 " vec4 resHEREult = vec4(1, 0, 0, 1);\n" 4059 "\n" 4060 " if (vec4(0, 0, 1, 1) == texelFetch(uni_sampler, coordinates, 0 /* lod */))\n" 4061 " {\n" 4062 " SET_RESULT(vec4(0, 1, 0, 1));\n" 4063 " }\n" 4064 "\n" 4065 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), resHEREult);\n" 4066 "}\n" 4067 ""; 4068 4069 static const GLchar* fragment_shader_template = 4070 "VERSION\n" 4071 "\n" 4072 "in vec4 gs_fs_result;\n" 4073 "in vec2 gs_fs_tex_coord;\n" 4074 "out vec4 fs_out_result;\n" 4075 "uniform sampler2D uni_sampler;\n" 4076 "\n" 4077 "#define SET_RESULT(XX) resHEREult = XX\n" 4078 "\n" 4079 "void main()\n" 4080 "{\n" 4081 " vec4 resHEREult = vec4(1, 0, 0, 1);\n" 4082 "\n" 4083 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, gs_fs_tex_coord)) &&\n" 4084 " (vec4(0, 1, 0, 1) == gs_fs_result) )\n" 4085 " {\n" 4086 " SET_RESULT(vec4(0, 1, 0, 1));\n" 4087 " }\n" 4088 "\n" 4089 " fs_out_result = resHEREult;\n" 4090 "}\n" 4091 "\n"; 4092 4093 static const GLchar* geometry_shader_template = 4094 "VERSION\n" 4095 "\n" 4096 "layout(points) in;\n" 4097 "layout(triangle_strip, max_vertices = 4) out;\n" 4098 "\n" 4099 "in vec4 tes_gHEREs_result[];\n" 4100 "out vec2 gs_fs_tex_coord;\n" 4101 "out vec4 gs_fs_result;\n" 4102 "uniform sampler2D uni_sampler;\n" 4103 "\n" 4104 "#define SET_RESULT(XX) result = XX\n" 4105 "\n" 4106 "void main()\n" 4107 "{\n" 4108 " vec4 result = vec4(1, 0, 0, 1);\n" 4109 "\n" 4110 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.5, 0.5))) &&\n" 4111 " (vec4(0, 1, 0, 1) == tes_gHEREs_result[0]) )\n" 4112 " {\n" 4113 " SET_RESULT(vec4(0, 1, 0, 1));\n" 4114 " }\n" 4115 "\n" 4116 " gs_fs_tex_coord = vec2(0.25, 0.25);\n" 4117 " gs_fs_result = result;\n" 4118 " gl_Position = vec4(-1, -1, 0, 1);\n" 4119 " EmitVertex();\n" 4120 " gs_fs_tex_coord = vec2(0.25, 0.75);\n" 4121 " gs_fs_result = result;\n" 4122 " gl_Position = vec4(-1, 1, 0, 1);\n" 4123 " EmitVertex();\n" 4124 " gs_fs_tex_coord = vec2(0.75, 0.25);\n" 4125 " gs_fs_result = result;\n" 4126 " gl_Position = vec4(1, -1, 0, 1);\n" 4127 " EmitVertex();\n" 4128 " gs_fs_tex_coord = vec2(0.75, 0.75);\n" 4129 " gs_fs_result = result;\n" 4130 " gl_Position = vec4(1, 1, 0, 1);\n" 4131 " EmitVertex();\n" 4132 "}\n" 4133 "\n"; 4134 4135 static const GLchar* tess_ctrl_shader_template = 4136 "VERSION\n" 4137 "\n" 4138 "layout(vertices = 1) out;\n" 4139 "\n" 4140 "in vec4 vs_tcs_result[];\n" 4141 "out vec4 tcHEREs_tes_result[];\n" 4142 "uniform sampler2D uni_sampler;\n" 4143 "\n" 4144 "#define SET_RESULT(XX) resulHEREt = XX\n" 4145 "\n" 4146 "void main()\n" 4147 "{\n" 4148 " vec4 resulHEREt = vec4(1, 0, 0, 1);\n" 4149 "\n" 4150 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.4, 0.4))) &&\n" 4151 " (vec4(0, 1, 0, 1) == vs_tcs_result[gl_InvocationID]) )\n" 4152 " {\n" 4153 " SET_RESULT(vec4(0, 1, 0, 1));\n" 4154 " }\n" 4155 "\n" 4156 " tcHEREs_tes_result[gl_InvocationID] = resulHEREt;\n" 4157 "\n" 4158 " gl_TessLevelOuter[0] = 1.0;\n" 4159 " gl_TessLevelOuter[1] = 1.0;\n" 4160 " gl_TessLevelOuter[2] = 1.0;\n" 4161 " gl_TessLevelOuter[3] = 1.0;\n" 4162 " gl_TessLevelInner[0] = 1.0;\n" 4163 " gl_TessLevelInner[1] = 1.0;\n" 4164 "}\n" 4165 "\n"; 4166 4167 static const GLchar* tess_eval_shader_template = 4168 "VERSION\n" 4169 "\n" 4170 "layout(isolines, point_mode) in;\n" 4171 "\n" 4172 "in vec4 tcs_tes_result[];\n" 4173 "out vec4 teHEREs_gs_result;\n" 4174 "uniform sampler2D uni_sampler;\n" 4175 "\n" 4176 "#define SET_RESULT(XX) reHEREsult = XX\n" 4177 "\n" 4178 "void main()\n" 4179 "{\n" 4180 " vec4 reHEREsult = vec4(1, 0, 0, 1);\n" 4181 "\n" 4182 " if ((vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.6, 0.6))) &&\n" 4183 " (vec4(0, 1, 0, 1) == tcs_tes_result[0]) )\n" 4184 " {\n" 4185 " SET_RESULT(vec4(0, 1, 0, 1));\n" 4186 " }\n" 4187 "\n" 4188 " teHEREs_gs_result = reHEREsult;\n" 4189 "}\n" 4190 "\n"; 4191 4192 static const GLchar* vertex_shader_template = "VERSION\n" 4193 "\n" 4194 "out vec4 vs_tcs_HEREresult;\n" 4195 "uniform sampler2D uni_sampler;\n" 4196 "\n" 4197 "#define SET_RHEREESULT(XX) resHEREult = XX\n" 4198 "\n" 4199 "void main()\n" 4200 "{\n" 4201 " vec4 resHEREult = vec4(1, 0, 0, 1);\n" 4202 "\n" 4203 " if (vec4(0, 0, 1, 1) == texture(uni_sampler, vec2(0.5, 0.5)) )\n" 4204 " {\n" 4205 " SET_RHEREESULT(vec4(0, 1, 0, 1));\n" 4206 " }\n" 4207 "\n" 4208 " vs_tcs_HEREresult = resHEREult;\n" 4209 "}\n" 4210 "\n"; 4211 4212 const GLchar* shader_template = 0; 4213 const GLchar* utf8_character = Utils::getUtf8Character(m_character); 4214 4215 switch (in_stage) 4216 { 4217 case Utils::COMPUTE_SHADER: 4218 shader_template = compute_shader_template; 4219 break; 4220 case Utils::FRAGMENT_SHADER: 4221 shader_template = fragment_shader_template; 4222 break; 4223 case Utils::GEOMETRY_SHADER: 4224 shader_template = geometry_shader_template; 4225 break; 4226 case Utils::TESS_CTRL_SHADER: 4227 shader_template = tess_ctrl_shader_template; 4228 break; 4229 case Utils::TESS_EVAL_SHADER: 4230 shader_template = tess_eval_shader_template; 4231 break; 4232 case Utils::VERTEX_SHADER: 4233 shader_template = vertex_shader_template; 4234 break; 4235 default: 4236 TCU_FAIL("Invalid enum"); 4237 break; 4238 } 4239 4240 out_source.m_parts[0].m_code = shader_template; 4241 4242 size_t position = 0; 4243 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 4244 out_source.m_parts[0].m_code); 4245 4246 Utils::replaceAllTokens("HERE", utf8_character, out_source.m_parts[0].m_code); 4247 } 4248 4249 /** Constructor 4250 * 4251 * @param context Test context 4252 **/ 4253 ImplicitConversionsValidTest::ImplicitConversionsValidTest(deqp::Context& context) 4254 : GLSLTestBase(context, "implicit_conversions", "Verifies that implicit conversions are allowed") 4255 { 4256 /* Nothing to be done */ 4257 } 4258 4259 /** Set up next test case 4260 * 4261 * @param test_case_index Index of next test case 4262 * 4263 * @return false if there is no more test cases, true otherwise 4264 **/ 4265 bool ImplicitConversionsValidTest::prepareNextTestCase(glw::GLuint test_case_index) 4266 { 4267 m_current_test_case_index = test_case_index; 4268 4269 if ((glw::GLuint)-1 == test_case_index) 4270 { 4271 return true; 4272 } 4273 else if (m_test_cases.size() <= test_case_index) 4274 { 4275 return false; 4276 } 4277 4278 const testCase& test_case = m_test_cases[test_case_index]; 4279 4280 m_context.getTestContext().getLog() << tcu::TestLog::Message 4281 << "T1:" << Utils::getTypeName(test_case.m_types.m_t1, test_case.m_n_cols, 4282 test_case.m_n_rows) 4283 << " T2:" << Utils::getTypeName(test_case.m_types.m_t2, test_case.m_n_cols, 4284 test_case.m_n_rows) 4285 << tcu::TestLog::EndMessage; 4286 4287 return true; 4288 } 4289 4290 /** Prepare source for given shader stage 4291 * 4292 * @param in_stage Shader stage, compute shader will use 430 4293 * @param in_use_version_400 Select if 400 or 420 should be used 4294 * @param out_source Prepared shader source instance 4295 **/ 4296 void ImplicitConversionsValidTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 4297 Utils::shaderSource& out_source) 4298 { 4299 static const GLchar* function_definition = "T1 function(in T2 left, in T2 right)\n" 4300 "{\n" 4301 " return left + right;\n" 4302 "}\n"; 4303 4304 static const GLchar* verification_snippet = " const T2 const_left = T2(VALUE_LIST);\n" 4305 " const T2 const_right = T2(VALUE_LIST);\n" 4306 "\n" 4307 " T1 const_result = function(const_left, const_right);\n" 4308 "\n" 4309 " T1 literal_result = function(T2(VALUE_LIST), T2(VALUE_LIST));\n" 4310 "\n" 4311 " T2 var_left = uni_left;\n" 4312 " T2 var_right = uni_right;\n" 4313 "\n" 4314 " T1 var_result = function(var_left, var_right);\n" 4315 "\n" 4316 " if ((literal_result != const_result) ||\n" 4317 " (const_result != var_result) )\n" 4318 " {\n" 4319 " result = vec4(1, 0, 0, 1);\n" 4320 " }\n"; 4321 4322 static const GLchar* compute_shader_template = 4323 "VERSION\n" 4324 "\n" 4325 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 4326 "\n" 4327 "writeonly uniform image2D uni_image;\n" 4328 " uniform T2 uni_left;\n" 4329 " uniform T2 uni_right;\n" 4330 "\n" 4331 "FUNCTION_DEFINITION" 4332 "\n" 4333 "void main()\n" 4334 "{\n" 4335 " vec4 result = vec4(0, 1, 0, 1);\n" 4336 "\n" 4337 "VERIFICATION" 4338 "\n" 4339 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 4340 "}\n" 4341 "\n"; 4342 4343 static const GLchar* fragment_shader_template = "VERSION\n" 4344 "\n" 4345 "in vec4 gs_fs_result;\n" 4346 "out vec4 fs_out_result;\n" 4347 "uniform T2 uni_left;\n" 4348 "uniform T2 uni_right;\n" 4349 "\n" 4350 "FUNCTION_DEFINITION" 4351 "\n" 4352 "void main()\n" 4353 "{\n" 4354 " vec4 result = vec4(0, 1, 0, 1);\n" 4355 "\n" 4356 "VERIFICATION" 4357 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 4358 " {\n" 4359 " result = vec4(1, 0, 0, 1);\n" 4360 " }\n" 4361 "\n" 4362 " fs_out_result = result;\n" 4363 "}\n" 4364 "\n"; 4365 4366 static const GLchar* geometry_shader_template = "VERSION\n" 4367 "\n" 4368 "layout(points) in;\n" 4369 "layout(triangle_strip, max_vertices = 4) out;\n" 4370 "\n" 4371 "in vec4 tes_gs_result[];\n" 4372 "out vec4 gs_fs_result;\n" 4373 "uniform T2 uni_left;\n" 4374 "uniform T2 uni_right;\n" 4375 "\n" 4376 "FUNCTION_DEFINITION" 4377 "\n" 4378 "void main()\n" 4379 "{\n" 4380 " vec4 result = vec4(0, 1, 0, 1);\n" 4381 "\n" 4382 "VERIFICATION" 4383 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 4384 " {\n" 4385 " result = vec4(1, 0, 0, 1);\n" 4386 " }\n" 4387 "\n" 4388 " gs_fs_result = result;\n" 4389 " gl_Position = vec4(-1, -1, 0, 1);\n" 4390 " EmitVertex();\n" 4391 " gs_fs_result = result;\n" 4392 " gl_Position = vec4(-1, 1, 0, 1);\n" 4393 " EmitVertex();\n" 4394 " gs_fs_result = result;\n" 4395 " gl_Position = vec4(1, -1, 0, 1);\n" 4396 " EmitVertex();\n" 4397 " gs_fs_result = result;\n" 4398 " gl_Position = vec4(1, 1, 0, 1);\n" 4399 " EmitVertex();\n" 4400 "}\n" 4401 "\n"; 4402 4403 static const GLchar* tess_ctrl_shader_template = 4404 "VERSION\n" 4405 "\n" 4406 "layout(vertices = 1) out;\n" 4407 "\n" 4408 "in vec4 vs_tcs_result[];\n" 4409 "out vec4 tcs_tes_result[];\n" 4410 "uniform T2 uni_left;\n" 4411 "uniform T2 uni_right;\n" 4412 "\n" 4413 "FUNCTION_DEFINITION" 4414 "\n" 4415 "void main()\n" 4416 "{\n" 4417 " vec4 result = vec4(0, 1, 0, 1);\n" 4418 "\n" 4419 "VERIFICATION" 4420 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 4421 " {\n" 4422 " result = vec4(1, 0, 0, 1);\n" 4423 " }\n" 4424 "\n" 4425 " tcs_tes_result[gl_InvocationID] = result;\n" 4426 "\n" 4427 " gl_TessLevelOuter[0] = 1.0;\n" 4428 " gl_TessLevelOuter[1] = 1.0;\n" 4429 " gl_TessLevelOuter[2] = 1.0;\n" 4430 " gl_TessLevelOuter[3] = 1.0;\n" 4431 " gl_TessLevelInner[0] = 1.0;\n" 4432 " gl_TessLevelInner[1] = 1.0;\n" 4433 "}\n" 4434 "\n"; 4435 4436 static const GLchar* tess_eval_shader_template = "VERSION\n" 4437 "\n" 4438 "layout(isolines, point_mode) in;\n" 4439 "\n" 4440 "in vec4 tcs_tes_result[];\n" 4441 "out vec4 tes_gs_result;\n" 4442 "uniform T2 uni_left;\n" 4443 "uniform T2 uni_right;\n" 4444 "\n" 4445 "FUNCTION_DEFINITION" 4446 "\n" 4447 "void main()\n" 4448 "{\n" 4449 " vec4 result = vec4(0, 1, 0, 1);\n" 4450 "\n" 4451 "VERIFICATION" 4452 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 4453 " {\n" 4454 " result = vec4(1, 0, 0, 1);\n" 4455 " }\n" 4456 "\n" 4457 " tes_gs_result = result;\n" 4458 "}\n" 4459 "\n"; 4460 4461 static const GLchar* vertex_shader_template = "VERSION\n" 4462 "\n" 4463 "out vec4 vs_tcs_result;\n" 4464 "uniform T2 uni_left;\n" 4465 "uniform T2 uni_right;\n" 4466 "\n" 4467 "FUNCTION_DEFINITION" 4468 "\n" 4469 "void main()\n" 4470 "{\n" 4471 " vec4 result = vec4(0, 1, 0, 1);\n" 4472 "\n" 4473 "VERIFICATION" 4474 "\n" 4475 " vs_tcs_result = result;\n" 4476 "}\n" 4477 "\n"; 4478 4479 const testCase& test_case = getCurrentTestCase(); 4480 const GLchar* t1 = Utils::getTypeName(test_case.m_types.m_t1, test_case.m_n_cols, test_case.m_n_rows); 4481 const GLchar* t2 = Utils::getTypeName(test_case.m_types.m_t2, test_case.m_n_cols, test_case.m_n_rows); 4482 const std::string& value_list = getValueList(test_case.m_n_cols, test_case.m_n_rows); 4483 const GLchar* shader_template = 0; 4484 4485 switch (in_stage) 4486 { 4487 case Utils::COMPUTE_SHADER: 4488 shader_template = compute_shader_template; 4489 break; 4490 case Utils::FRAGMENT_SHADER: 4491 shader_template = fragment_shader_template; 4492 break; 4493 case Utils::GEOMETRY_SHADER: 4494 shader_template = geometry_shader_template; 4495 break; 4496 case Utils::TESS_CTRL_SHADER: 4497 shader_template = tess_ctrl_shader_template; 4498 break; 4499 case Utils::TESS_EVAL_SHADER: 4500 shader_template = tess_eval_shader_template; 4501 break; 4502 case Utils::VERTEX_SHADER: 4503 shader_template = vertex_shader_template; 4504 break; 4505 default: 4506 TCU_FAIL("Invalid enum"); 4507 break; 4508 } 4509 4510 out_source.m_parts[0].m_code = shader_template; 4511 4512 size_t position = 0; 4513 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 4514 out_source.m_parts[0].m_code); 4515 4516 Utils::replaceToken("FUNCTION_DEFINITION", position, function_definition, out_source.m_parts[0].m_code); 4517 4518 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 4519 4520 Utils::replaceAllTokens("VALUE_LIST", value_list.c_str(), out_source.m_parts[0].m_code); 4521 4522 Utils::replaceAllTokens("T1", t1, out_source.m_parts[0].m_code); 4523 4524 Utils::replaceAllTokens("T2", t2, out_source.m_parts[0].m_code); 4525 } 4526 4527 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 4528 * 4529 * @param program Current program 4530 **/ 4531 void ImplicitConversionsValidTest::prepareUniforms(Utils::program& program) 4532 { 4533 static const GLdouble double_data[16] = { 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 4534 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 }; 4535 static const GLfloat float_data[16] = { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 4536 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; 4537 static const GLint int_data[4] = { 1, 1, 1, 1 }; 4538 static const GLuint uint_data[4] = { 1u, 1u, 1u, 1u }; 4539 4540 const testCase& test_case = getCurrentTestCase(); 4541 4542 switch (test_case.m_types.m_t2) 4543 { 4544 case Utils::DOUBLE: 4545 program.uniform("uni_left", Utils::DOUBLE, test_case.m_n_cols, test_case.m_n_rows, double_data); 4546 program.uniform("uni_right", Utils::DOUBLE, test_case.m_n_cols, test_case.m_n_rows, double_data); 4547 break; 4548 case Utils::FLOAT: 4549 program.uniform("uni_left", Utils::FLOAT, test_case.m_n_cols, test_case.m_n_rows, float_data); 4550 program.uniform("uni_right", Utils::FLOAT, test_case.m_n_cols, test_case.m_n_rows, float_data); 4551 break; 4552 case Utils::INT: 4553 program.uniform("uni_left", Utils::INT, test_case.m_n_cols, test_case.m_n_rows, int_data); 4554 program.uniform("uni_right", Utils::INT, test_case.m_n_cols, test_case.m_n_rows, int_data); 4555 break; 4556 case Utils::UINT: 4557 program.uniform("uni_left", Utils::UINT, test_case.m_n_cols, test_case.m_n_rows, uint_data); 4558 program.uniform("uni_right", Utils::UINT, test_case.m_n_cols, test_case.m_n_rows, uint_data); 4559 break; 4560 default: 4561 TCU_FAIL("Invalid enum"); 4562 } 4563 } 4564 4565 /** Prepare test cases 4566 * 4567 * @return true 4568 **/ 4569 bool ImplicitConversionsValidTest::testInit() 4570 { 4571 static const typesPair allowed_conversions[] = { 4572 { Utils::UINT, Utils::INT }, { Utils::FLOAT, Utils::INT }, { Utils::DOUBLE, Utils::INT }, 4573 { Utils::FLOAT, Utils::UINT }, { Utils::DOUBLE, Utils::UINT }, { Utils::FLOAT, Utils::FLOAT }, 4574 }; 4575 4576 static GLuint n_allowed_conversions = sizeof(allowed_conversions) / sizeof(typesPair); 4577 4578 m_debug_test_case.m_types.m_t1 = Utils::FLOAT; 4579 m_debug_test_case.m_types.m_t2 = Utils::FLOAT; 4580 m_debug_test_case.m_n_cols = 4; 4581 m_debug_test_case.m_n_rows = 4; 4582 4583 for (GLuint i = 0; i < n_allowed_conversions; ++i) 4584 { 4585 const typesPair& types = allowed_conversions[i]; 4586 4587 GLuint allowed_columns = 1; 4588 if ((true == Utils::doesTypeSupportMatrix(types.m_t1)) && (true == Utils::doesTypeSupportMatrix(types.m_t2))) 4589 { 4590 allowed_columns = 4; 4591 } 4592 4593 { 4594 testCase test_case = { types, 1, 1 }; 4595 4596 m_test_cases.push_back(test_case); 4597 } 4598 4599 for (GLuint row = 2; row <= 4; ++row) 4600 { 4601 for (GLuint col = 1; col <= allowed_columns; ++col) 4602 { 4603 testCase test_case = { types, col, row }; 4604 4605 m_test_cases.push_back(test_case); 4606 } 4607 } 4608 } 4609 4610 return true; 4611 } 4612 4613 /** Returns reference to current test case 4614 * 4615 * @return Reference to testCase 4616 **/ 4617 const ImplicitConversionsValidTest::testCase& ImplicitConversionsValidTest::getCurrentTestCase() 4618 { 4619 if ((glw::GLuint)-1 == m_current_test_case_index) 4620 { 4621 return m_debug_test_case; 4622 } 4623 else 4624 { 4625 return m_test_cases[m_current_test_case_index]; 4626 } 4627 } 4628 4629 /** Get list of values to for glsl constants 4630 * 4631 * @param n_columns Number of columns 4632 * @param n_rows Number of rows 4633 * 4634 * @return String with list of values separated with comma 4635 **/ 4636 std::string ImplicitConversionsValidTest::getValueList(glw::GLuint n_columns, glw::GLuint n_rows) 4637 { 4638 std::string result; 4639 4640 for (GLuint i = 0; i < n_columns * n_rows; ++i) 4641 { 4642 if (i != n_columns * n_rows - 1) 4643 { 4644 result.append("1, "); 4645 } 4646 else 4647 { 4648 result.append("1"); 4649 } 4650 } 4651 4652 return result; 4653 } 4654 4655 /** Constructor 4656 * 4657 * @param context Test context 4658 **/ 4659 ImplicitConversionsInvalidTest::ImplicitConversionsInvalidTest(deqp::Context& context) 4660 : NegativeTestBase(context, "implicit_conversions_invalid", 4661 "Verifies that implicit conversions from uint to int are forbidden") 4662 { 4663 /* Nothing to be done here */ 4664 } 4665 4666 /** Set up next test case 4667 * 4668 * @param test_case_index Index of next test case 4669 * 4670 * @return false if there is no more test cases, true otherwise 4671 **/ 4672 bool ImplicitConversionsInvalidTest::prepareNextTestCase(glw::GLuint test_case_index) 4673 { 4674 m_current_test_case_index = test_case_index; 4675 4676 if ((glw::GLuint)-1 == test_case_index) 4677 { 4678 return false; 4679 } 4680 else if (4 <= test_case_index) 4681 { 4682 return false; 4683 } 4684 4685 m_context.getTestContext().getLog() << tcu::TestLog::Message 4686 << "T1:" << Utils::getTypeName(Utils::UINT, 1, test_case_index + 1) 4687 << " T2:" << Utils::getTypeName(Utils::INT, 1, test_case_index + 1) 4688 << tcu::TestLog::EndMessage; 4689 4690 return true; 4691 } 4692 4693 /** Prepare source for given shader stage 4694 * 4695 * @param in_stage Shader stage, compute shader will use 430 4696 * @param in_use_version_400 Select if 400 or 420 should be used 4697 * @param out_source Prepared shader source instance 4698 **/ 4699 void ImplicitConversionsInvalidTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 4700 Utils::shaderSource& out_source) 4701 { 4702 static const GLchar* function_definition = "T1 function(in T2 left, in T2 right)\n" 4703 "{\n" 4704 " return left + right;\n" 4705 "}\n"; 4706 4707 static const GLchar* verification_snippet = " const T2 const_left = T2(VALUE_LIST);\n" 4708 " const T2 const_right = T2(VALUE_LIST);\n" 4709 "\n" 4710 " T1 const_result = function(const_left, const_right);\n" 4711 "\n" 4712 " T1 literal_result = function(T2(VALUE_LIST), T2(VALUE_LIST));\n" 4713 "\n" 4714 " T2 var_left = uni_left;\n" 4715 " T2 var_right = uni_right;\n" 4716 "\n" 4717 " T1 var_result = function(var_left, var_right);\n" 4718 "\n" 4719 " if ((literal_result != const_result) ||\n" 4720 " (const_result != var_result) )\n" 4721 " {\n" 4722 " result = vec4(1, 0, 0, 1);\n" 4723 " }\n"; 4724 4725 static const GLchar* compute_shader_template = 4726 "VERSION\n" 4727 "\n" 4728 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 4729 "\n" 4730 "writeonly uniform image2D uni_image;\n" 4731 " uniform T2 uni_left;\n" 4732 " uniform T2 uni_right;\n" 4733 "\n" 4734 "FUNCTION_DEFINITION" 4735 "\n" 4736 "void main()\n" 4737 "{\n" 4738 " vec4 result = vec4(0, 1, 0, 1);\n" 4739 "\n" 4740 "VERIFICATION" 4741 "\n" 4742 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 4743 "}\n" 4744 "\n"; 4745 4746 static const GLchar* fragment_shader_template = "VERSION\n" 4747 "\n" 4748 "in vec4 gs_fs_result;\n" 4749 "out vec4 fs_out_result;\n" 4750 "uniform T2 uni_left;\n" 4751 "uniform T2 uni_right;\n" 4752 "\n" 4753 "FUNCTION_DEFINITION" 4754 "\n" 4755 "void main()\n" 4756 "{\n" 4757 " vec4 result = vec4(0, 1, 0, 1);\n" 4758 "\n" 4759 "VERIFICATION" 4760 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 4761 " {\n" 4762 " result = vec4(1, 0, 0, 1);\n" 4763 " }\n" 4764 "\n" 4765 " fs_out_result = result;\n" 4766 "}\n" 4767 "\n"; 4768 4769 static const GLchar* geometry_shader_template = "VERSION\n" 4770 "\n" 4771 "layout(points) in;\n" 4772 "layout(triangle_strip, max_vertices = 4) out;\n" 4773 "\n" 4774 "in vec4 tes_gs_result[];\n" 4775 "out vec4 gs_fs_result;\n" 4776 "uniform T2 uni_left;\n" 4777 "uniform T2 uni_right;\n" 4778 "\n" 4779 "FUNCTION_DEFINITION" 4780 "\n" 4781 "void main()\n" 4782 "{\n" 4783 " vec4 result = vec4(0, 1, 0, 1);\n" 4784 "\n" 4785 "VERIFICATION" 4786 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 4787 " {\n" 4788 " result = vec4(1, 0, 0, 1);\n" 4789 " }\n" 4790 "\n" 4791 " gs_fs_result = result;\n" 4792 " gl_Position = vec4(-1, -1, 0, 1);\n" 4793 " EmitVertex();\n" 4794 " gs_fs_result = result;\n" 4795 " gl_Position = vec4(-1, 1, 0, 1);\n" 4796 " EmitVertex();\n" 4797 " gs_fs_result = result;\n" 4798 " gl_Position = vec4(1, -1, 0, 1);\n" 4799 " EmitVertex();\n" 4800 " gs_fs_result = result;\n" 4801 " gl_Position = vec4(1, 1, 0, 1);\n" 4802 " EmitVertex();\n" 4803 "}\n" 4804 "\n"; 4805 4806 static const GLchar* tess_ctrl_shader_template = 4807 "VERSION\n" 4808 "\n" 4809 "layout(vertices = 1) out;\n" 4810 "\n" 4811 "in vec4 vs_tcs_result[];\n" 4812 "out vec4 tcs_tes_result[];\n" 4813 "uniform T2 uni_left;\n" 4814 "uniform T2 uni_right;\n" 4815 "\n" 4816 "FUNCTION_DEFINITION" 4817 "\n" 4818 "void main()\n" 4819 "{\n" 4820 " vec4 result = vec4(0, 1, 0, 1);\n" 4821 "\n" 4822 "VERIFICATION" 4823 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 4824 " {\n" 4825 " result = vec4(1, 0, 0, 1);\n" 4826 " }\n" 4827 "\n" 4828 " tcs_tes_result[gl_InvocationID] = result;\n" 4829 "\n" 4830 " gl_TessLevelOuter[0] = 1.0;\n" 4831 " gl_TessLevelOuter[1] = 1.0;\n" 4832 " gl_TessLevelOuter[2] = 1.0;\n" 4833 " gl_TessLevelOuter[3] = 1.0;\n" 4834 " gl_TessLevelInner[0] = 1.0;\n" 4835 " gl_TessLevelInner[1] = 1.0;\n" 4836 "}\n" 4837 "\n"; 4838 4839 static const GLchar* tess_eval_shader_template = "VERSION\n" 4840 "\n" 4841 "layout(isolines, point_mode) in;\n" 4842 "\n" 4843 "in vec4 tcs_tes_result[];\n" 4844 "out vec4 tes_gs_result;\n" 4845 "uniform T2 uni_left;\n" 4846 "uniform T2 uni_right;\n" 4847 "\n" 4848 "FUNCTION_DEFINITION" 4849 "\n" 4850 "void main()\n" 4851 "{\n" 4852 " vec4 result = vec4(0, 1, 0, 1);\n" 4853 "\n" 4854 "VERIFICATION" 4855 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 4856 " {\n" 4857 " result = vec4(1, 0, 0, 1);\n" 4858 " }\n" 4859 "\n" 4860 " tes_gs_result = result;\n" 4861 "}\n" 4862 "\n"; 4863 4864 static const GLchar* vertex_shader_template = "VERSION\n" 4865 "\n" 4866 "out vec4 vs_tcs_result;\n" 4867 "uniform T2 uni_left;\n" 4868 "uniform T2 uni_right;\n" 4869 "\n" 4870 "FUNCTION_DEFINITION" 4871 "\n" 4872 "void main()\n" 4873 "{\n" 4874 " vec4 result = vec4(0, 1, 0, 1);\n" 4875 "\n" 4876 "VERIFICATION" 4877 "\n" 4878 " vs_tcs_result = result;\n" 4879 "}\n" 4880 "\n"; 4881 4882 GLuint n_rows = m_current_test_case_index + 1; 4883 const GLchar* t1 = Utils::getTypeName(Utils::INT, 1, n_rows); 4884 const GLchar* t2 = Utils::getTypeName(Utils::UINT, 1, n_rows); 4885 const std::string& value_list = getValueList(n_rows); 4886 const GLchar* shader_template = 0; 4887 4888 switch (in_stage) 4889 { 4890 case Utils::COMPUTE_SHADER: 4891 shader_template = compute_shader_template; 4892 break; 4893 case Utils::FRAGMENT_SHADER: 4894 shader_template = fragment_shader_template; 4895 break; 4896 case Utils::GEOMETRY_SHADER: 4897 shader_template = geometry_shader_template; 4898 break; 4899 case Utils::TESS_CTRL_SHADER: 4900 shader_template = tess_ctrl_shader_template; 4901 break; 4902 case Utils::TESS_EVAL_SHADER: 4903 shader_template = tess_eval_shader_template; 4904 break; 4905 case Utils::VERTEX_SHADER: 4906 shader_template = vertex_shader_template; 4907 break; 4908 default: 4909 TCU_FAIL("Invalid enum"); 4910 break; 4911 } 4912 4913 out_source.m_parts[0].m_code = shader_template; 4914 4915 size_t position = 0; 4916 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 4917 out_source.m_parts[0].m_code); 4918 4919 Utils::replaceToken("FUNCTION_DEFINITION", position, function_definition, out_source.m_parts[0].m_code); 4920 4921 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 4922 4923 Utils::replaceAllTokens("VALUE_LIST", value_list.c_str(), out_source.m_parts[0].m_code); 4924 4925 Utils::replaceAllTokens("T1", t1, out_source.m_parts[0].m_code); 4926 4927 Utils::replaceAllTokens("T2", t2, out_source.m_parts[0].m_code); 4928 } 4929 4930 /** Get list of values to for glsl constants 4931 * 4932 * @return String with list of values separated with comma 4933 **/ 4934 std::string ImplicitConversionsInvalidTest::getValueList(glw::GLuint n_rows) 4935 { 4936 std::string result; 4937 4938 for (GLuint i = 0; i < n_rows; ++i) 4939 { 4940 if (i != n_rows - 1) 4941 { 4942 result.append("1, "); 4943 } 4944 else 4945 { 4946 result.append("1"); 4947 } 4948 } 4949 4950 return result; 4951 } 4952 4953 /** Constructor 4954 * 4955 * @param context Test context 4956 **/ 4957 ConstDynamicValueTest::ConstDynamicValueTest(deqp::Context& context) 4958 : GLSLTestBase(context, "const_dynamic_value", "Test if constants can be initialized with dynamic values") 4959 { 4960 /* Nothing to be done here */ 4961 } 4962 4963 /** Prepare source for given shader stage 4964 * 4965 * @param in_stage Shader stage, compute shader will use 430 4966 * @param in_use_version_400 Select if 400 or 420 should be used 4967 * @param out_source Prepared shader source instance 4968 **/ 4969 void ConstDynamicValueTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 4970 Utils::shaderSource& out_source) 4971 { 4972 static const GLchar* struct_definition = "struct S {\n" 4973 " float scalar;\n" 4974 " vec4 vector;\n" 4975 " mat2 matrix;\n" 4976 "};\n"; 4977 4978 static const GLchar* verification_snippet = " const float c1 = uni_scalar;\n" 4979 " const vec4 c2 = uni_vector;\n" 4980 " const mat2 c3 = uni_matrix;\n" 4981 " const S c4 = { uni_scalar, uni_vector, uni_matrix };\n" 4982 " const vec4 c5[15] = { uni_vector,\n" 4983 " uni_vector,\n" 4984 " uni_vector,\n" 4985 " uni_vector,\n" 4986 " uni_vector,\n" 4987 " uni_vector,\n" 4988 " uni_vector,\n" 4989 " uni_vector,\n" 4990 " uni_vector,\n" 4991 " uni_vector,\n" 4992 " uni_vector,\n" 4993 " uni_vector,\n" 4994 " uni_vector,\n" 4995 " uni_vector,\n" 4996 " uni_vector };\n" 4997 " if ((SCALAR != c1) ||\n" 4998 " (VECTOR != c2) ||\n" 4999 " (MATRIX != c3) ||\n" 5000 " (SCALAR != c4.scalar) ||\n" 5001 " (VECTOR != c4.vector) ||\n" 5002 " (MATRIX != c4.matrix) ||\n" 5003 " (VECTOR != c5[0]) ||\n" 5004 " (VECTOR != c5[1]) ||\n" 5005 " (VECTOR != c5[2]) ||\n" 5006 " (VECTOR != c5[3]) ||\n" 5007 " (VECTOR != c5[4]) ||\n" 5008 " (VECTOR != c5[5]) ||\n" 5009 " (VECTOR != c5[6]) ||\n" 5010 " (VECTOR != c5[7]) ||\n" 5011 " (VECTOR != c5[8]) ||\n" 5012 " (VECTOR != c5[9]) ||\n" 5013 " (VECTOR != c5[10]) ||\n" 5014 " (VECTOR != c5[11]) ||\n" 5015 " (VECTOR != c5[12]) ||\n" 5016 " (VECTOR != c5[13]) ||\n" 5017 " (VECTOR != c5[14]) )\n" 5018 " {\n" 5019 " result = vec4(1, 0, 0, 1);\n" 5020 " }\n"; 5021 5022 static const GLchar* compute_shader_template = 5023 "VERSION\n" 5024 "\n" 5025 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 5026 "\n" 5027 "writeonly uniform image2D uni_image;\n" 5028 " uniform float uni_scalar;\n" 5029 " uniform vec4 uni_vector;\n" 5030 " uniform mat2 uni_matrix;\n" 5031 "\n" 5032 "STRUCTURE_DEFINITION" 5033 "\n" 5034 "void main()\n" 5035 "{\n" 5036 " vec4 result = vec4(0, 1, 0, 1);\n" 5037 "\n" 5038 "VERIFICATION" 5039 "\n" 5040 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 5041 "}\n" 5042 "\n"; 5043 5044 static const GLchar* fragment_shader_template = "VERSION\n" 5045 "\n" 5046 "in vec4 gs_fs_result;\n" 5047 "out vec4 fs_out_result;\n" 5048 "uniform float uni_scalar;\n" 5049 "uniform vec4 uni_vector;\n" 5050 "uniform mat2 uni_matrix;\n" 5051 "\n" 5052 "STRUCTURE_DEFINITION" 5053 "\n" 5054 "void main()\n" 5055 "{\n" 5056 " vec4 result = vec4(0, 1, 0, 1);\n" 5057 "\n" 5058 "VERIFICATION" 5059 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 5060 " {\n" 5061 " result = vec4(1, 0, 0, 1);\n" 5062 " }\n" 5063 "\n" 5064 " fs_out_result = result;\n" 5065 "}\n" 5066 "\n"; 5067 5068 static const GLchar* geometry_shader_template = "VERSION\n" 5069 "\n" 5070 "layout(points) in;\n" 5071 "layout(triangle_strip, max_vertices = 4) out;\n" 5072 "\n" 5073 "in vec4 tes_gs_result[];\n" 5074 "out vec4 gs_fs_result;\n" 5075 "uniform float uni_scalar;\n" 5076 "uniform vec4 uni_vector;\n" 5077 "uniform mat2 uni_matrix;\n" 5078 "\n" 5079 "STRUCTURE_DEFINITION" 5080 "\n" 5081 "void main()\n" 5082 "{\n" 5083 " vec4 result = vec4(0, 1, 0, 1);\n" 5084 "\n" 5085 "VERIFICATION" 5086 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 5087 " {\n" 5088 " result = vec4(1, 0, 0, 1);\n" 5089 " }\n" 5090 "\n" 5091 " gs_fs_result = result;\n" 5092 " gl_Position = vec4(-1, -1, 0, 1);\n" 5093 " EmitVertex();\n" 5094 " gs_fs_result = result;\n" 5095 " gl_Position = vec4(-1, 1, 0, 1);\n" 5096 " EmitVertex();\n" 5097 " gs_fs_result = result;\n" 5098 " gl_Position = vec4(1, -1, 0, 1);\n" 5099 " EmitVertex();\n" 5100 " gs_fs_result = result;\n" 5101 " gl_Position = vec4(1, 1, 0, 1);\n" 5102 " EmitVertex();\n" 5103 "}\n" 5104 "\n"; 5105 5106 static const GLchar* tess_ctrl_shader_template = 5107 "VERSION\n" 5108 "\n" 5109 "layout(vertices = 1) out;\n" 5110 "\n" 5111 "in vec4 vs_tcs_result[];\n" 5112 "out vec4 tcs_tes_result[];\n" 5113 "uniform float uni_scalar;\n" 5114 "uniform vec4 uni_vector;\n" 5115 "uniform mat2 uni_matrix;\n" 5116 "\n" 5117 "STRUCTURE_DEFINITION" 5118 "\n" 5119 "void main()\n" 5120 "{\n" 5121 " vec4 result = vec4(0, 1, 0, 1);\n" 5122 "\n" 5123 "VERIFICATION" 5124 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 5125 " {\n" 5126 " result = vec4(1, 0, 0, 1);\n" 5127 " }\n" 5128 "\n" 5129 " tcs_tes_result[gl_InvocationID] = result;\n" 5130 "\n" 5131 " gl_TessLevelOuter[0] = 1.0;\n" 5132 " gl_TessLevelOuter[1] = 1.0;\n" 5133 " gl_TessLevelOuter[2] = 1.0;\n" 5134 " gl_TessLevelOuter[3] = 1.0;\n" 5135 " gl_TessLevelInner[0] = 1.0;\n" 5136 " gl_TessLevelInner[1] = 1.0;\n" 5137 "}\n" 5138 "\n"; 5139 5140 static const GLchar* tess_eval_shader_template = "VERSION\n" 5141 "\n" 5142 "layout(isolines, point_mode) in;\n" 5143 "\n" 5144 "in vec4 tcs_tes_result[];\n" 5145 "out vec4 tes_gs_result;\n" 5146 "uniform float uni_scalar;\n" 5147 "uniform vec4 uni_vector;\n" 5148 "uniform mat2 uni_matrix;\n" 5149 "\n" 5150 "STRUCTURE_DEFINITION" 5151 "\n" 5152 "void main()\n" 5153 "{\n" 5154 " vec4 result = vec4(0, 1, 0, 1);\n" 5155 "\n" 5156 "VERIFICATION" 5157 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 5158 " {\n" 5159 " result = vec4(1, 0, 0, 1);\n" 5160 " }\n" 5161 "\n" 5162 " tes_gs_result = result;\n" 5163 "}\n" 5164 "\n"; 5165 5166 static const GLchar* vertex_shader_template = "VERSION\n" 5167 "\n" 5168 "out vec4 vs_tcs_result;\n" 5169 "uniform float uni_scalar;\n" 5170 "uniform vec4 uni_vector;\n" 5171 "uniform mat2 uni_matrix;\n" 5172 "\n" 5173 "STRUCTURE_DEFINITION" 5174 "\n" 5175 "void main()\n" 5176 "{\n" 5177 " vec4 result = vec4(0, 1, 0, 1);\n" 5178 "\n" 5179 "VERIFICATION" 5180 "\n" 5181 " vs_tcs_result = result;\n" 5182 "}\n" 5183 "\n"; 5184 5185 static const GLchar* scalar = "0.5"; 5186 static const GLchar* vector = "vec4(0.5, 0.125, 0.375, 0)"; 5187 static const GLchar* matrix = "mat2(0.5, 0.125, 0.375, 0)"; 5188 5189 const GLchar* shader_template = 0; 5190 5191 switch (in_stage) 5192 { 5193 case Utils::COMPUTE_SHADER: 5194 shader_template = compute_shader_template; 5195 break; 5196 case Utils::FRAGMENT_SHADER: 5197 shader_template = fragment_shader_template; 5198 break; 5199 case Utils::GEOMETRY_SHADER: 5200 shader_template = geometry_shader_template; 5201 break; 5202 case Utils::TESS_CTRL_SHADER: 5203 shader_template = tess_ctrl_shader_template; 5204 break; 5205 case Utils::TESS_EVAL_SHADER: 5206 shader_template = tess_eval_shader_template; 5207 break; 5208 case Utils::VERTEX_SHADER: 5209 shader_template = vertex_shader_template; 5210 break; 5211 default: 5212 TCU_FAIL("Invalid enum"); 5213 break; 5214 } 5215 5216 out_source.m_parts[0].m_code = shader_template; 5217 5218 size_t position = 0; 5219 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 5220 out_source.m_parts[0].m_code); 5221 5222 Utils::replaceToken("STRUCTURE_DEFINITION", position, struct_definition, out_source.m_parts[0].m_code); 5223 5224 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 5225 5226 Utils::replaceAllTokens("SCALAR", scalar, out_source.m_parts[0].m_code); 5227 5228 Utils::replaceAllTokens("VECTOR", vector, out_source.m_parts[0].m_code); 5229 5230 Utils::replaceAllTokens("MATRIX", matrix, out_source.m_parts[0].m_code); 5231 } 5232 5233 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 5234 * 5235 * @param program Current program 5236 **/ 5237 void ConstDynamicValueTest::prepareUniforms(Utils::program& program) 5238 { 5239 static const GLfloat float_data[4] = { 0.5f, 0.125f, 0.375f, 0.0f }; 5240 static const GLfloat scalar = 0.5f; 5241 5242 program.uniform("uni_scalar", Utils::FLOAT, 1, 1, &scalar); 5243 program.uniform("uni_vector", Utils::FLOAT, 1, 4, float_data); 5244 program.uniform("uni_matrix", Utils::FLOAT, 2, 2, float_data); 5245 } 5246 5247 /** Constructor 5248 * 5249 * @param context Test context 5250 **/ 5251 ConstAssignmentTest::ConstAssignmentTest(deqp::Context& context) 5252 : NegativeTestBase(context, "const_assignment", "Verifies that constants cannot be overwritten") 5253 { 5254 /* Nothing to be done here */ 5255 } 5256 5257 /** Set up next test case 5258 * 5259 * @param test_case_index Index of next test case 5260 * 5261 * @return false if there is no more test cases, true otherwise 5262 **/ 5263 bool ConstAssignmentTest::prepareNextTestCase(glw::GLuint test_case_index) 5264 { 5265 m_current_test_case_index = test_case_index; 5266 5267 if ((glw::GLuint)-1 == test_case_index) 5268 { 5269 return true; 5270 } 5271 else if (2 <= test_case_index) 5272 { 5273 return false; 5274 } 5275 5276 return true; 5277 } 5278 5279 /** Prepare source for given shader stage 5280 * 5281 * @param in_stage Shader stage, compute shader will use 430 5282 * @param in_use_version_400 Select if 400 or 420 should be used 5283 * @param out_source Prepared shader source instance 5284 **/ 5285 void ConstAssignmentTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 5286 Utils::shaderSource& out_source) 5287 { 5288 static const GLchar* verification_snippet = " const float c1 = INIT;\n" 5289 "\n" 5290 " float temp = c1;\n" 5291 "\n" 5292 " for (uint i = 0; i < 4; ++i)" 5293 " {\n" 5294 " temp += c1 + uni_value;\n" 5295 " c1 -= 0.125;\n" 5296 " }\n" 5297 "\n" 5298 " if (0.0 == temp)\n" 5299 " {\n" 5300 " result = vec4(1, 0, 0, 1);\n" 5301 " }\n"; 5302 5303 static const GLchar* compute_shader_template = 5304 "VERSION\n" 5305 "\n" 5306 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 5307 "\n" 5308 "writeonly uniform image2D uni_image;\n" 5309 " uniform float uni_value;\n" 5310 "\n" 5311 "void main()\n" 5312 "{\n" 5313 " vec4 result = vec4(0, 1, 0, 1);\n" 5314 "\n" 5315 "VERIFICATION" 5316 "\n" 5317 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 5318 "}\n" 5319 "\n"; 5320 5321 static const GLchar* fragment_shader_template = "VERSION\n" 5322 "\n" 5323 "in vec4 gs_fs_result;\n" 5324 "out vec4 fs_out_result;\n" 5325 "uniform float uni_value;\n" 5326 "\n" 5327 "void main()\n" 5328 "{\n" 5329 " vec4 result = vec4(0, 1, 0, 1);\n" 5330 "\n" 5331 "VERIFICATION" 5332 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 5333 " {\n" 5334 " result = vec4(1, 0, 0, 1);\n" 5335 " }\n" 5336 "\n" 5337 " fs_out_result = result;\n" 5338 "}\n" 5339 "\n"; 5340 5341 static const GLchar* geometry_shader_template = "VERSION\n" 5342 "\n" 5343 "layout(points) in;\n" 5344 "layout(triangle_strip, max_vertices = 4) out;\n" 5345 "\n" 5346 "in vec4 tes_gs_result[];\n" 5347 "out vec4 gs_fs_result;\n" 5348 "uniform float uni_value;\n" 5349 "\n" 5350 "void main()\n" 5351 "{\n" 5352 " vec4 result = vec4(0, 1, 0, 1);\n" 5353 "\n" 5354 "VERIFICATION" 5355 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 5356 " {\n" 5357 " result = vec4(1, 0, 0, 1);\n" 5358 " }\n" 5359 "\n" 5360 " gs_fs_result = result;\n" 5361 " gl_Position = vec4(-1, -1, 0, 1);\n" 5362 " EmitVertex();\n" 5363 " gs_fs_result = result;\n" 5364 " gl_Position = vec4(-1, 1, 0, 1);\n" 5365 " EmitVertex();\n" 5366 " gs_fs_result = result;\n" 5367 " gl_Position = vec4(1, -1, 0, 1);\n" 5368 " EmitVertex();\n" 5369 " gs_fs_result = result;\n" 5370 " gl_Position = vec4(1, 1, 0, 1);\n" 5371 " EmitVertex();\n" 5372 "}\n" 5373 "\n"; 5374 5375 static const GLchar* tess_ctrl_shader_template = 5376 "VERSION\n" 5377 "\n" 5378 "layout(vertices = 1) out;\n" 5379 "\n" 5380 "in vec4 vs_tcs_result[];\n" 5381 "out vec4 tcs_tes_result[];\n" 5382 "uniform float uni_value;\n" 5383 "\n" 5384 "void main()\n" 5385 "{\n" 5386 " vec4 result = vec4(0, 1, 0, 1);\n" 5387 "\n" 5388 "VERIFICATION" 5389 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 5390 " {\n" 5391 " result = vec4(1, 0, 0, 1);\n" 5392 " }\n" 5393 "\n" 5394 " tcs_tes_result[gl_InvocationID] = result;\n" 5395 "\n" 5396 " gl_TessLevelOuter[0] = 1.0;\n" 5397 " gl_TessLevelOuter[1] = 1.0;\n" 5398 " gl_TessLevelOuter[2] = 1.0;\n" 5399 " gl_TessLevelOuter[3] = 1.0;\n" 5400 " gl_TessLevelInner[0] = 1.0;\n" 5401 " gl_TessLevelInner[1] = 1.0;\n" 5402 "}\n" 5403 "\n"; 5404 5405 static const GLchar* tess_eval_shader_template = "VERSION\n" 5406 "\n" 5407 "layout(isolines, point_mode) in;\n" 5408 "\n" 5409 "in vec4 tcs_tes_result[];\n" 5410 "out vec4 tes_gs_result;\n" 5411 "uniform float uni_value;\n" 5412 "\n" 5413 "void main()\n" 5414 "{\n" 5415 " vec4 result = vec4(0, 1, 0, 1);\n" 5416 "\n" 5417 "VERIFICATION" 5418 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 5419 " {\n" 5420 " result = vec4(1, 0, 0, 1);\n" 5421 " }\n" 5422 "\n" 5423 " tes_gs_result = result;\n" 5424 "}\n" 5425 "\n"; 5426 5427 static const GLchar* vertex_shader_template = "VERSION\n" 5428 "\n" 5429 "out vec4 vs_tcs_result;\n" 5430 "uniform float uni_value;\n" 5431 "\n" 5432 "void main()\n" 5433 "{\n" 5434 " vec4 result = vec4(0, 1, 0, 1);\n" 5435 "\n" 5436 "VERIFICATION" 5437 "\n" 5438 " vs_tcs_result = result;\n" 5439 "}\n" 5440 "\n"; 5441 5442 static const GLchar* dynamic_init = "uni_value"; 5443 static const GLchar* const_init = "0.75"; 5444 5445 const GLchar* shader_template = 0; 5446 const GLchar* l_init = 0; 5447 5448 switch (in_stage) 5449 { 5450 case Utils::COMPUTE_SHADER: 5451 shader_template = compute_shader_template; 5452 break; 5453 case Utils::FRAGMENT_SHADER: 5454 shader_template = fragment_shader_template; 5455 break; 5456 case Utils::GEOMETRY_SHADER: 5457 shader_template = geometry_shader_template; 5458 break; 5459 case Utils::TESS_CTRL_SHADER: 5460 shader_template = tess_ctrl_shader_template; 5461 break; 5462 case Utils::TESS_EVAL_SHADER: 5463 shader_template = tess_eval_shader_template; 5464 break; 5465 case Utils::VERTEX_SHADER: 5466 shader_template = vertex_shader_template; 5467 break; 5468 default: 5469 TCU_FAIL("Invalid enum"); 5470 break; 5471 } 5472 5473 if (0 == m_current_test_case_index) 5474 { 5475 l_init = dynamic_init; 5476 } 5477 else 5478 { 5479 l_init = const_init; 5480 } 5481 5482 out_source.m_parts[0].m_code = shader_template; 5483 5484 size_t position = 0; 5485 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 5486 out_source.m_parts[0].m_code); 5487 5488 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 5489 5490 Utils::replaceAllTokens("INIT", l_init, out_source.m_parts[0].m_code); 5491 } 5492 5493 /** Constructor 5494 * 5495 * @param context Test context 5496 **/ 5497 ConstDynamicValueAsConstExprTest::ConstDynamicValueAsConstExprTest(deqp::Context& context) 5498 : NegativeTestBase(context, "const_dynamic_value_as_const_expr", 5499 "Verifies that dynamic constants cannot be used as constant foldable expressions") 5500 { 5501 /* Nothing to be done here */ 5502 } 5503 5504 /** Prepare source for given shader stage 5505 * 5506 * @param in_stage Shader stage, compute shader will use 430 5507 * @param in_use_version_400 Select if 400 or 420 should be used 5508 * @param out_source Prepared shader source instance 5509 **/ 5510 void ConstDynamicValueAsConstExprTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 5511 Utils::shaderSource& out_source) 5512 { 5513 static const GLchar* verification_snippet = " const uint c1 = INIT;\n" 5514 "\n" 5515 " float temp[c1];\n" 5516 "\n" 5517 " for (uint i = 0; i < c1; ++i)" 5518 " {\n" 5519 " temp[i] += uni_value;\n" 5520 " }\n" 5521 "\n" 5522 " if (0.0 == temp[c1 - 1])\n" 5523 " {\n" 5524 " result = vec4(1, 0, 0, 1);\n" 5525 " }\n"; 5526 5527 static const GLchar* compute_shader_template = 5528 "VERSION\n" 5529 "\n" 5530 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 5531 "\n" 5532 "writeonly uniform image2D uni_image;\n" 5533 " uniform uint uni_value;\n" 5534 "\n" 5535 "void main()\n" 5536 "{\n" 5537 " vec4 result = vec4(0, 1, 0, 1);\n" 5538 "\n" 5539 "VERIFICATION" 5540 "\n" 5541 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 5542 "}\n" 5543 "\n"; 5544 5545 static const GLchar* fragment_shader_template = "VERSION\n" 5546 "\n" 5547 "in vec4 gs_fs_result;\n" 5548 "out vec4 fs_out_result;\n" 5549 "uniform uint uni_value;\n" 5550 "\n" 5551 "void main()\n" 5552 "{\n" 5553 " vec4 result = vec4(0, 1, 0, 1);\n" 5554 "\n" 5555 "VERIFICATION" 5556 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 5557 " {\n" 5558 " result = vec4(1, 0, 0, 1);\n" 5559 " }\n" 5560 "\n" 5561 " fs_out_result = result;\n" 5562 "}\n" 5563 "\n"; 5564 5565 static const GLchar* geometry_shader_template = "VERSION\n" 5566 "\n" 5567 "layout(points) in;\n" 5568 "layout(triangle_strip, max_vertices = 4) out;\n" 5569 "\n" 5570 "in vec4 tes_gs_result[];\n" 5571 "out vec4 gs_fs_result;\n" 5572 "uniform uint uni_value;\n" 5573 "\n" 5574 "void main()\n" 5575 "{\n" 5576 " vec4 result = vec4(0, 1, 0, 1);\n" 5577 "\n" 5578 "VERIFICATION" 5579 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 5580 " {\n" 5581 " result = vec4(1, 0, 0, 1);\n" 5582 " }\n" 5583 "\n" 5584 " gs_fs_result = result;\n" 5585 " gl_Position = vec4(-1, -1, 0, 1);\n" 5586 " EmitVertex();\n" 5587 " gs_fs_result = result;\n" 5588 " gl_Position = vec4(-1, 1, 0, 1);\n" 5589 " EmitVertex();\n" 5590 " gs_fs_result = result;\n" 5591 " gl_Position = vec4(1, -1, 0, 1);\n" 5592 " EmitVertex();\n" 5593 " gs_fs_result = result;\n" 5594 " gl_Position = vec4(1, 1, 0, 1);\n" 5595 " EmitVertex();\n" 5596 "}\n" 5597 "\n"; 5598 5599 static const GLchar* tess_ctrl_shader_template = 5600 "VERSION\n" 5601 "\n" 5602 "layout(vertices = 1) out;\n" 5603 "\n" 5604 "in vec4 vs_tcs_result[];\n" 5605 "out vec4 tcs_tes_result[];\n" 5606 "uniform uint uni_value;\n" 5607 "\n" 5608 "void main()\n" 5609 "{\n" 5610 " vec4 result = vec4(0, 1, 0, 1);\n" 5611 "\n" 5612 "VERIFICATION" 5613 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 5614 " {\n" 5615 " result = vec4(1, 0, 0, 1);\n" 5616 " }\n" 5617 "\n" 5618 " tcs_tes_result[gl_InvocationID] = result;\n" 5619 "\n" 5620 " gl_TessLevelOuter[0] = 1.0;\n" 5621 " gl_TessLevelOuter[1] = 1.0;\n" 5622 " gl_TessLevelOuter[2] = 1.0;\n" 5623 " gl_TessLevelOuter[3] = 1.0;\n" 5624 " gl_TessLevelInner[0] = 1.0;\n" 5625 " gl_TessLevelInner[1] = 1.0;\n" 5626 "}\n" 5627 "\n"; 5628 5629 static const GLchar* tess_eval_shader_template = "VERSION\n" 5630 "\n" 5631 "layout(isolines, point_mode) in;\n" 5632 "\n" 5633 "in vec4 tcs_tes_result[];\n" 5634 "out vec4 tes_gs_result;\n" 5635 "uniform uint uni_value;\n" 5636 "\n" 5637 "void main()\n" 5638 "{\n" 5639 " vec4 result = vec4(0, 1, 0, 1);\n" 5640 "\n" 5641 "VERIFICATION" 5642 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 5643 " {\n" 5644 " result = vec4(1, 0, 0, 1);\n" 5645 " }\n" 5646 "\n" 5647 " tes_gs_result = result;\n" 5648 "}\n" 5649 "\n"; 5650 5651 static const GLchar* vertex_shader_template = "VERSION\n" 5652 "\n" 5653 "out vec4 vs_tcs_result;\n" 5654 "uniform uint uni_value;\n" 5655 "\n" 5656 "void main()\n" 5657 "{\n" 5658 " vec4 result = vec4(0, 1, 0, 1);\n" 5659 "\n" 5660 "VERIFICATION" 5661 "\n" 5662 " vs_tcs_result = result;\n" 5663 "}\n" 5664 "\n"; 5665 5666 static const GLchar* l_init = "uni_value"; 5667 5668 const GLchar* shader_template = 0; 5669 5670 switch (in_stage) 5671 { 5672 case Utils::COMPUTE_SHADER: 5673 shader_template = compute_shader_template; 5674 break; 5675 case Utils::FRAGMENT_SHADER: 5676 shader_template = fragment_shader_template; 5677 break; 5678 case Utils::GEOMETRY_SHADER: 5679 shader_template = geometry_shader_template; 5680 break; 5681 case Utils::TESS_CTRL_SHADER: 5682 shader_template = tess_ctrl_shader_template; 5683 break; 5684 case Utils::TESS_EVAL_SHADER: 5685 shader_template = tess_eval_shader_template; 5686 break; 5687 case Utils::VERTEX_SHADER: 5688 shader_template = vertex_shader_template; 5689 break; 5690 default: 5691 TCU_FAIL("Invalid enum"); 5692 break; 5693 } 5694 5695 out_source.m_parts[0].m_code = shader_template; 5696 5697 size_t position = 0; 5698 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 5699 out_source.m_parts[0].m_code); 5700 5701 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 5702 5703 Utils::replaceAllTokens("INIT", l_init, out_source.m_parts[0].m_code); 5704 } 5705 5706 /** Constructor 5707 * 5708 * @param context Test context 5709 **/ 5710 QualifierOrderTest::QualifierOrderTest(deqp::Context& context) 5711 : GLSLTestBase(context, "qualifier_order", 5712 "Test verifies that valid permutation of input and output qalifiers are accepted") 5713 { 5714 /* Nothing to be done */ 5715 } 5716 5717 /** Set up next test case 5718 * 5719 * @param test_case_index Index of next test case 5720 * 5721 * @return false if there is no more test cases, true otherwise 5722 **/ 5723 bool QualifierOrderTest::prepareNextTestCase(glw::GLuint test_case_index) 5724 { 5725 m_current_test_case_index = test_case_index; 5726 5727 if ((glw::GLuint)-1 == test_case_index) 5728 { 5729 /* Nothing to be done here */; 5730 } 5731 else if (m_test_cases.size() <= test_case_index) 5732 { 5733 return false; 5734 } 5735 5736 const Utils::qualifierSet& set = getCurrentTestCase(); 5737 5738 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 5739 5740 for (GLuint i = 0; i < set.size(); ++i) 5741 { 5742 message << Utils::getQualifierString(set[i]) << " "; 5743 } 5744 5745 message << tcu::TestLog::EndMessage; 5746 5747 return true; 5748 } 5749 5750 /** Prepare source for given shader stage 5751 * 5752 * @param in_stage Shader stage, compute shader will use 430 5753 * @param in_use_version_400 Select if 400 or 420 should be used 5754 * @param out_source Prepared shader source instance 5755 **/ 5756 void QualifierOrderTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 5757 Utils::shaderSource& out_source) 5758 { 5759 static const GLchar* verification_snippet = 5760 " vec4 diff = INPUT_VARIABLE_NAME - vec4(0, 0, 1, 1);\n" 5761 " if (false == all(lessThan(diff, vec4(0.001, 0.001, 0.001, 0.001))))\n" 5762 " {\n" 5763 " result = INPUT_VARIABLE_NAME;\n" 5764 " }\n"; 5765 5766 static const GLchar* fragment_shader_template = "VERSION\n" 5767 "\n" 5768 "in vec4 gs_fs_result;\n" 5769 "layout (location = 0) out vec4 fs_out_result;\n" 5770 "\n" 5771 "VARIABLE_DECLARATION;\n" 5772 "VARIABLE_DECLARATION;\n" 5773 "\n" 5774 "void main()\n" 5775 "{\n" 5776 " vec4 result = vec4(0, 1, 0, 1);\n" 5777 "\n" 5778 "VERIFICATION" 5779 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 5780 " {\n" 5781 " result = vec4(1, 0, 0, 1);\n" 5782 " }\n" 5783 "\n" 5784 " fs_out_result = result;\n" 5785 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5786 "}\n" 5787 "\n"; 5788 5789 static const GLchar* geometry_shader_template = "VERSION\n" 5790 "\n" 5791 "layout(points) in;\n" 5792 "layout(triangle_strip, max_vertices = 4) out;\n" 5793 "\n" 5794 "in vec4 tes_gs_result[];\n" 5795 "out vec4 gs_fs_result;\n" 5796 "\n" 5797 "VARIABLE_DECLARATION;\n" 5798 "VARIABLE_DECLARATION;\n" 5799 "\n" 5800 "void main()\n" 5801 "{\n" 5802 " vec4 result = vec4(0, 1, 0, 1);\n" 5803 "\n" 5804 "VERIFICATION" 5805 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 5806 " {\n" 5807 " result = vec4(1, 0, 0, 1);\n" 5808 " }\n" 5809 "\n" 5810 " gs_fs_result = result;\n" 5811 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5812 " gl_Position = vec4(-1, -1, 0, 1);\n" 5813 " EmitVertex();\n" 5814 " gs_fs_result = result;\n" 5815 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5816 " gl_Position = vec4(-1, 1, 0, 1);\n" 5817 " EmitVertex();\n" 5818 " gs_fs_result = result;\n" 5819 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5820 " gl_Position = vec4(1, -1, 0, 1);\n" 5821 " EmitVertex();\n" 5822 " gs_fs_result = result;\n" 5823 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5824 " gl_Position = vec4(1, 1, 0, 1);\n" 5825 " EmitVertex();\n" 5826 "}\n" 5827 "\n"; 5828 5829 static const GLchar* tess_ctrl_shader_template = 5830 "VERSION\n" 5831 "\n" 5832 "layout(vertices = 1) out;\n" 5833 "\n" 5834 "in vec4 vs_tcs_result[];\n" 5835 "out vec4 tcs_tes_result[];\n" 5836 "\n" 5837 "VARIABLE_DECLARATION;\n" 5838 "VARIABLE_DECLARATION;\n" 5839 "\n" 5840 "void main()\n" 5841 "{\n" 5842 " vec4 result = vec4(0, 1, 0, 1);\n" 5843 "\n" 5844 "VERIFICATION" 5845 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 5846 " {\n" 5847 " result = vec4(1, 0, 0, 1);\n" 5848 " }\n" 5849 "\n" 5850 " tcs_tes_result[gl_InvocationID] = result;\n" 5851 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5852 "\n" 5853 " gl_TessLevelOuter[0] = 1.0;\n" 5854 " gl_TessLevelOuter[1] = 1.0;\n" 5855 " gl_TessLevelOuter[2] = 1.0;\n" 5856 " gl_TessLevelOuter[3] = 1.0;\n" 5857 " gl_TessLevelInner[0] = 1.0;\n" 5858 " gl_TessLevelInner[1] = 1.0;\n" 5859 "}\n" 5860 "\n"; 5861 5862 static const GLchar* tess_eval_shader_template = "VERSION\n" 5863 "\n" 5864 "layout(isolines, point_mode) in;\n" 5865 "\n" 5866 "in vec4 tcs_tes_result[];\n" 5867 "out vec4 tes_gs_result;\n" 5868 "\n" 5869 "VARIABLE_DECLARATION;\n" 5870 "VARIABLE_DECLARATION;\n" 5871 "\n" 5872 "void main()\n" 5873 "{\n" 5874 " vec4 result = vec4(0, 1, 0, 1);\n" 5875 "\n" 5876 "VERIFICATION" 5877 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 5878 " {\n" 5879 " result = vec4(1, 0, 0, 1);\n" 5880 " }\n" 5881 "\n" 5882 " tes_gs_result = result;\n" 5883 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5884 "}\n" 5885 "\n"; 5886 5887 static const GLchar* vertex_shader_template = "VERSION\n" 5888 "\n" 5889 "out vec4 vs_tcs_result;\n" 5890 "\n" 5891 "VARIABLE_DECLARATION;\n" 5892 "VARIABLE_DECLARATION;\n" 5893 "\n" 5894 "void main()\n" 5895 "{\n" 5896 " vec4 result = vec4(0, 1, 0, 1);\n" 5897 "\n" 5898 "VERIFICATION" 5899 "\n" 5900 " vs_tcs_result = result;\n" 5901 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 5902 "}\n" 5903 "\n"; 5904 5905 const GLchar* shader_template = 0; 5906 5907 switch (in_stage) 5908 { 5909 case Utils::COMPUTE_SHADER: 5910 return; 5911 break; 5912 case Utils::FRAGMENT_SHADER: 5913 shader_template = fragment_shader_template; 5914 break; 5915 case Utils::GEOMETRY_SHADER: 5916 shader_template = geometry_shader_template; 5917 break; 5918 case Utils::TESS_CTRL_SHADER: 5919 shader_template = tess_ctrl_shader_template; 5920 break; 5921 case Utils::TESS_EVAL_SHADER: 5922 shader_template = tess_eval_shader_template; 5923 break; 5924 case Utils::VERTEX_SHADER: 5925 shader_template = vertex_shader_template; 5926 break; 5927 default: 5928 TCU_FAIL("Invalid enum"); 5929 break; 5930 } 5931 5932 const Utils::qualifierSet& test_case = getCurrentTestCase(); 5933 5934 std::string in_test_decl; 5935 std::string in_test_ref; 5936 std::string out_test_decl; 5937 std::string out_test_ref; 5938 5939 Utils::prepareVariableStrings(in_stage, Utils::INPUT, test_case, "vec4", "test", in_test_decl, in_test_ref); 5940 Utils::prepareVariableStrings(in_stage, Utils::OUTPUT, test_case, "vec4", "test", out_test_decl, out_test_ref); 5941 5942 // sample storage qualifier is not a valid qualifier for fragment output 5943 if (in_stage == Utils::FRAGMENT_SHADER) 5944 { 5945 if (out_test_decl.find("sample") != std::string::npos) 5946 out_test_decl.erase(out_test_decl.find("sample"), 7); 5947 } 5948 5949 out_source.m_parts[0].m_code = shader_template; 5950 5951 size_t position = 0; 5952 5953 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 5954 out_source.m_parts[0].m_code); 5955 5956 Utils::replaceToken("VARIABLE_DECLARATION", position, in_test_decl.c_str(), out_source.m_parts[0].m_code); 5957 5958 Utils::replaceToken("VARIABLE_DECLARATION", position, out_test_decl.c_str(), out_source.m_parts[0].m_code); 5959 5960 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 5961 5962 position -= strlen(verification_snippet); 5963 5964 Utils::replaceAllTokens("OUTPUT_VARIABLE_NAME", out_test_ref.c_str(), out_source.m_parts[0].m_code); 5965 5966 Utils::replaceAllTokens("INPUT_VARIABLE_NAME", in_test_ref.c_str(), out_source.m_parts[0].m_code); 5967 5968 Utils::replaceAllTokens("LOC_VALUE", "1", out_source.m_parts[0].m_code); 5969 } 5970 5971 /**Prepare vertex buffer and vertex array object. 5972 * 5973 * @param program Program instance 5974 * @param buffer Buffer instance 5975 * @param vao VertexArray instance 5976 * 5977 * @return 0 5978 **/ 5979 void QualifierOrderTest::prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, 5980 Utils::vertexArray& vao) 5981 { 5982 std::string test_name = Utils::getVariableName(Utils::VERTEX_SHADER, Utils::INPUT, "test"); 5983 GLint test_loc = program.getAttribLocation(test_name.c_str()); 5984 5985 if (-1 == test_loc) 5986 { 5987 TCU_FAIL("Vertex attribute location is invalid"); 5988 } 5989 5990 vao.generate(); 5991 vao.bind(); 5992 5993 buffer.generate(GL_ARRAY_BUFFER); 5994 5995 GLfloat data[] = { 0.0f, 0.0f, 1.0f, 1.0f }; 5996 GLsizeiptr data_size = sizeof(data); 5997 5998 buffer.update(data_size, data, GL_STATIC_DRAW); 5999 6000 /* GL entry points */ 6001 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 6002 6003 /* Set up vao */ 6004 gl.vertexAttribPointer(test_loc, 4 /* size */, GL_FLOAT /* type */, GL_FALSE /* normalized*/, 0 /* stride */, 6005 0 /* offset */); 6006 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer"); 6007 6008 /* Enable attribute */ 6009 gl.enableVertexAttribArray(test_loc); 6010 GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray"); 6011 } 6012 6013 /** Prepare test cases 6014 * 6015 * @return true 6016 **/ 6017 bool QualifierOrderTest::testInit() 6018 { 6019 m_test_cases.resize(5); 6020 6021 m_test_cases[0].push_back(Utils::QUAL_HIGHP); 6022 m_test_cases[0].push_back(Utils::QUAL_IN); 6023 m_test_cases[0].push_back(Utils::QUAL_LOCATION); 6024 m_test_cases[0].push_back(Utils::QUAL_SMOOTH); 6025 m_test_cases[0].push_back(Utils::QUAL_INVARIANT); 6026 6027 m_test_cases[1].push_back(Utils::QUAL_LOWP); 6028 m_test_cases[1].push_back(Utils::QUAL_IN); 6029 m_test_cases[1].push_back(Utils::QUAL_SAMPLE); 6030 m_test_cases[1].push_back(Utils::QUAL_LOCATION); 6031 m_test_cases[1].push_back(Utils::QUAL_NOPERSPECTIVE); 6032 m_test_cases[1].push_back(Utils::QUAL_INVARIANT); 6033 6034 m_test_cases[2].push_back(Utils::QUAL_HIGHP); 6035 m_test_cases[2].push_back(Utils::QUAL_IN); 6036 m_test_cases[2].push_back(Utils::QUAL_LOCATION); 6037 m_test_cases[2].push_back(Utils::QUAL_SMOOTH); 6038 m_test_cases[2].push_back(Utils::QUAL_INVARIANT); 6039 m_test_cases[2].push_back(Utils::QUAL_LOCATION); 6040 6041 m_test_cases[3].push_back(Utils::QUAL_LOWP); 6042 m_test_cases[3].push_back(Utils::QUAL_IN); 6043 m_test_cases[3].push_back(Utils::QUAL_LOCATION); 6044 m_test_cases[3].push_back(Utils::QUAL_SAMPLE); 6045 m_test_cases[3].push_back(Utils::QUAL_LOCATION); 6046 m_test_cases[3].push_back(Utils::QUAL_NOPERSPECTIVE); 6047 m_test_cases[3].push_back(Utils::QUAL_INVARIANT); 6048 6049 m_test_cases[4].push_back(Utils::QUAL_HIGHP); 6050 m_test_cases[4].push_back(Utils::QUAL_IN); 6051 m_test_cases[4].push_back(Utils::QUAL_PATCH); 6052 m_test_cases[4].push_back(Utils::QUAL_LOCATION); 6053 m_test_cases[4].push_back(Utils::QUAL_INVARIANT); 6054 6055 return true; 6056 } 6057 6058 /** Returns reference to current test case 6059 * 6060 * @return Reference to testCase 6061 **/ 6062 const Utils::qualifierSet& QualifierOrderTest::getCurrentTestCase() 6063 { 6064 if ((glw::GLuint)-1 == m_current_test_case_index) 6065 { 6066 return m_test_cases[0]; 6067 } 6068 else 6069 { 6070 return m_test_cases[m_current_test_case_index]; 6071 } 6072 } 6073 6074 /** Constructor 6075 * 6076 * @param context Test context 6077 **/ 6078 QualifierOrderBlockTest::QualifierOrderBlockTest(deqp::Context& context) 6079 : GLSLTestBase(context, "qualifier_order_block", 6080 "Verifies that qualifiers of members of input block can be arranged in any order") 6081 { 6082 /* Nothing to be done here */ 6083 } 6084 6085 /** Set up next test case 6086 * 6087 * @param test_case_index Index of next test case 6088 * 6089 * @return false if there is no more test cases, true otherwise 6090 **/ 6091 bool QualifierOrderBlockTest::prepareNextTestCase(glw::GLuint test_case_index) 6092 { 6093 m_current_test_case_index = test_case_index; 6094 6095 if ((glw::GLuint)-1 == test_case_index) 6096 { 6097 /* Nothing to be done here */; 6098 } 6099 else if (m_test_cases.size() <= test_case_index) 6100 { 6101 return false; 6102 } 6103 6104 const Utils::qualifierSet& set = getCurrentTestCase(); 6105 6106 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 6107 6108 for (GLuint i = 0; i < set.size(); ++i) 6109 { 6110 message << Utils::getQualifierString(set[i]) << " "; 6111 } 6112 6113 message << tcu::TestLog::EndMessage; 6114 6115 return true; 6116 } 6117 6118 /** Prepare source for given shader stage 6119 * 6120 * @param in_stage Shader stage, compute shader will use 430 6121 * @param in_use_version_400 Select if 400 or 420 should be used 6122 * @param out_source Prepared shader source instance 6123 **/ 6124 void QualifierOrderBlockTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 6125 Utils::shaderSource& out_source) 6126 { 6127 static const GLchar* verification_snippet = 6128 " vec4 diff = INPUT_VARIABLE_NAME - vec4(0, 0, 1, 1);\n" 6129 " if (false == all(lessThan(diff, vec4(0.001, 0.001, 0.001, 0.001))))\n" 6130 " {\n" 6131 " result = INPUT_VARIABLE_NAME;\n" 6132 " }\n"; 6133 6134 static const GLchar* fragment_shader_template = "VERSION\n" 6135 "\n" 6136 "in vec4 gs_fs_result;\n" 6137 "layout (location = 0) out vec4 fs_out_result;\n" 6138 "\n" 6139 "in GSOutputBlock {\n" 6140 " VARIABLE_DECLARATION;\n" 6141 "} input_block;\n" 6142 "out VARIABLE_DECLARATION;\n" 6143 "\n" 6144 "void main()\n" 6145 "{\n" 6146 " vec4 result = vec4(0, 1, 0, 1);\n" 6147 "\n" 6148 "VERIFICATION" 6149 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 6150 " {\n" 6151 " result = vec4(1, 0, 0, 1);\n" 6152 " }\n" 6153 "\n" 6154 " fs_out_result = result;\n" 6155 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6156 "}\n" 6157 "\n"; 6158 6159 static const GLchar* geometry_shader_template = "VERSION\n" 6160 "\n" 6161 "layout(points) in;\n" 6162 "layout(triangle_strip, max_vertices = 4) out;\n" 6163 "\n" 6164 "in vec4 tes_gs_result[];\n" 6165 "out vec4 gs_fs_result;\n" 6166 "\n" 6167 "in TCSOutputBlock {\n" 6168 " VARIABLE_DECLARATION;\n" 6169 "} input_block [];\n" 6170 "out GSOutputBlock {\n" 6171 " VARIABLE_DECLARATION;\n" 6172 "} output_block;\n" 6173 "\n" 6174 "void main()\n" 6175 "{\n" 6176 " vec4 result = vec4(0, 1, 0, 1);\n" 6177 "\n" 6178 "VERIFICATION" 6179 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 6180 " {\n" 6181 " result = vec4(1, 0, 0, 1);\n" 6182 " }\n" 6183 "\n" 6184 " gs_fs_result = result;\n" 6185 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6186 " gl_Position = vec4(-1, -1, 0, 1);\n" 6187 " EmitVertex();\n" 6188 " gs_fs_result = result;\n" 6189 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6190 " gl_Position = vec4(-1, 1, 0, 1);\n" 6191 " EmitVertex();\n" 6192 " gs_fs_result = result;\n" 6193 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6194 " gl_Position = vec4(1, -1, 0, 1);\n" 6195 " EmitVertex();\n" 6196 " gs_fs_result = result;\n" 6197 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6198 " gl_Position = vec4(1, 1, 0, 1);\n" 6199 " EmitVertex();\n" 6200 "}\n" 6201 "\n"; 6202 6203 static const GLchar* tess_ctrl_shader_template = 6204 "VERSION\n" 6205 "\n" 6206 "layout(vertices = 1) out;\n" 6207 "\n" 6208 "in vec4 vs_tcs_result[];\n" 6209 "out vec4 tcs_tes_result[];\n" 6210 "\n" 6211 "in VSOutputBlock {\n" 6212 " VARIABLE_DECLARATION;\n" 6213 "} input_block [];\n" 6214 "out TCSOutputBlock {\n" 6215 " VARIABLE_DECLARATION;\n" 6216 "} output_block [];\n" 6217 "\n" 6218 "void main()\n" 6219 "{\n" 6220 " vec4 result = vec4(0, 1, 0, 1);\n" 6221 "\n" 6222 "VERIFICATION" 6223 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 6224 " {\n" 6225 " result = vec4(1, 0, 0, 1);\n" 6226 " }\n" 6227 "\n" 6228 " tcs_tes_result[gl_InvocationID] = result;\n" 6229 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6230 "\n" 6231 " gl_TessLevelOuter[0] = 1.0;\n" 6232 " gl_TessLevelOuter[1] = 1.0;\n" 6233 " gl_TessLevelOuter[2] = 1.0;\n" 6234 " gl_TessLevelOuter[3] = 1.0;\n" 6235 " gl_TessLevelInner[0] = 1.0;\n" 6236 " gl_TessLevelInner[1] = 1.0;\n" 6237 "}\n" 6238 "\n"; 6239 6240 static const GLchar* tess_eval_shader_template = "VERSION\n" 6241 "\n" 6242 "layout(isolines, point_mode) in;\n" 6243 "\n" 6244 "in vec4 tcs_tes_result[];\n" 6245 "out vec4 tes_gs_result;\n" 6246 "\n" 6247 "in TCSOutputBlock {\n" 6248 " VARIABLE_DECLARATION;\n" 6249 "} input_block [];\n" 6250 "out TCSOutputBlock {\n" 6251 " VARIABLE_DECLARATION;\n" 6252 "} output_block;\n" 6253 "\n" 6254 "void main()\n" 6255 "{\n" 6256 " vec4 result = vec4(0, 1, 0, 1);\n" 6257 "\n" 6258 "VERIFICATION" 6259 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 6260 " {\n" 6261 " result = vec4(1, 0, 0, 1);\n" 6262 " }\n" 6263 "\n" 6264 " tes_gs_result = result;\n" 6265 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6266 "}\n" 6267 "\n"; 6268 6269 static const GLchar* vertex_shader_template = "VERSION\n" 6270 "\n" 6271 "out vec4 vs_tcs_result;\n" 6272 "\n" 6273 "in VARIABLE_DECLARATION;\n" 6274 "out VSOutputBlock {\n" 6275 " VARIABLE_DECLARATION;\n" 6276 "} output_block;\n" 6277 "\n" 6278 "void main()\n" 6279 "{\n" 6280 " vec4 result = vec4(0, 1, 0, 1);\n" 6281 "\n" 6282 "VERIFICATION" 6283 "\n" 6284 " vs_tcs_result = result;\n" 6285 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 6286 "}\n" 6287 "\n"; 6288 6289 const GLchar* shader_template = 0; 6290 6291 switch (in_stage) 6292 { 6293 case Utils::COMPUTE_SHADER: 6294 return; 6295 break; 6296 case Utils::FRAGMENT_SHADER: 6297 shader_template = fragment_shader_template; 6298 break; 6299 case Utils::GEOMETRY_SHADER: 6300 shader_template = geometry_shader_template; 6301 break; 6302 case Utils::TESS_CTRL_SHADER: 6303 shader_template = tess_ctrl_shader_template; 6304 break; 6305 case Utils::TESS_EVAL_SHADER: 6306 shader_template = tess_eval_shader_template; 6307 break; 6308 case Utils::VERTEX_SHADER: 6309 shader_template = vertex_shader_template; 6310 break; 6311 default: 6312 TCU_FAIL("Invalid enum"); 6313 break; 6314 } 6315 6316 const Utils::qualifierSet& test_case = getCurrentTestCase(); 6317 6318 std::string in_test_decl; 6319 std::string in_test_ref; 6320 std::string out_test_decl; 6321 std::string out_test_ref; 6322 6323 switch (in_stage) 6324 { 6325 case Utils::VERTEX_SHADER: 6326 Utils::prepareVariableStrings(in_stage, Utils::INPUT, test_case, "vec4", "test", in_test_decl, in_test_ref); 6327 break; 6328 default: 6329 Utils::prepareBlockVariableStrings(in_stage, Utils::INPUT, test_case, "vec4", "test", "input_block", 6330 in_test_decl, in_test_ref); 6331 break; 6332 } 6333 6334 switch (in_stage) 6335 { 6336 case Utils::FRAGMENT_SHADER: 6337 Utils::prepareVariableStrings(in_stage, Utils::OUTPUT, test_case, "vec4", "test", out_test_decl, out_test_ref); 6338 break; 6339 default: 6340 Utils::prepareBlockVariableStrings(in_stage, Utils::OUTPUT, test_case, "vec4", "test", "output_block", 6341 out_test_decl, out_test_ref); 6342 break; 6343 } 6344 6345 // sample storage qualifier is not a valid qualifier for fragment output 6346 if (in_stage == Utils::FRAGMENT_SHADER) 6347 { 6348 if (out_test_decl.find("sample") != std::string::npos) 6349 out_test_decl.erase(out_test_decl.find("sample"), 7); 6350 } 6351 out_source.m_parts[0].m_code = shader_template; 6352 6353 size_t position = 0; 6354 6355 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 6356 out_source.m_parts[0].m_code); 6357 6358 Utils::replaceToken("VARIABLE_DECLARATION", position, in_test_decl.c_str(), out_source.m_parts[0].m_code); 6359 6360 Utils::replaceToken("VARIABLE_DECLARATION", position, out_test_decl.c_str(), out_source.m_parts[0].m_code); 6361 6362 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 6363 6364 position -= strlen(verification_snippet); 6365 6366 Utils::replaceAllTokens("OUTPUT_VARIABLE_NAME", out_test_ref.c_str(), out_source.m_parts[0].m_code); 6367 6368 Utils::replaceAllTokens("INPUT_VARIABLE_NAME", in_test_ref.c_str(), out_source.m_parts[0].m_code); 6369 6370 Utils::replaceAllTokens("LOC_VALUE", "1", out_source.m_parts[0].m_code); 6371 } 6372 6373 /**Prepare vertex buffer and vertex array object. 6374 * 6375 * @param program Program instance 6376 * @param buffer Buffer instance 6377 * @param vao VertexArray instance 6378 * 6379 * @return 0 6380 **/ 6381 void QualifierOrderBlockTest::prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, 6382 Utils::vertexArray& vao) 6383 { 6384 std::string test_name = Utils::getVariableName(Utils::VERTEX_SHADER, Utils::INPUT, "test"); 6385 GLint test_loc = program.getAttribLocation(test_name.c_str()); 6386 6387 if (-1 == test_loc) 6388 { 6389 TCU_FAIL("Vertex attribute location is invalid"); 6390 } 6391 6392 vao.generate(); 6393 vao.bind(); 6394 6395 buffer.generate(GL_ARRAY_BUFFER); 6396 6397 GLfloat data[] = { 0.0f, 0.0f, 1.0f, 1.0f }; 6398 GLsizeiptr data_size = sizeof(data); 6399 6400 buffer.update(data_size, data, GL_STATIC_DRAW); 6401 6402 /* GL entry points */ 6403 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 6404 6405 /* Set up vao */ 6406 gl.vertexAttribPointer(test_loc, 4 /* size */, GL_FLOAT /* type */, GL_FALSE /* normalized*/, 0 /* stride */, 6407 0 /* offset */); 6408 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer"); 6409 6410 /* Enable attribute */ 6411 gl.enableVertexAttribArray(test_loc); 6412 GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray"); 6413 } 6414 6415 /** Prepare test cases 6416 * 6417 * @return true 6418 **/ 6419 bool QualifierOrderBlockTest::testInit() 6420 { 6421 m_test_cases.resize(4); 6422 6423 m_test_cases[0].push_back(Utils::QUAL_HIGHP); 6424 m_test_cases[0].push_back(Utils::QUAL_FLAT); 6425 m_test_cases[0].push_back(Utils::QUAL_INVARIANT); 6426 6427 m_test_cases[1].push_back(Utils::QUAL_LOWP); 6428 m_test_cases[1].push_back(Utils::QUAL_SAMPLE); 6429 m_test_cases[1].push_back(Utils::QUAL_NOPERSPECTIVE); 6430 m_test_cases[1].push_back(Utils::QUAL_INVARIANT); 6431 6432 m_test_cases[2].push_back(Utils::QUAL_HIGHP); 6433 m_test_cases[2].push_back(Utils::QUAL_SMOOTH); 6434 m_test_cases[2].push_back(Utils::QUAL_INVARIANT); 6435 6436 m_test_cases[3].push_back(Utils::QUAL_LOWP); 6437 m_test_cases[3].push_back(Utils::QUAL_SAMPLE); 6438 m_test_cases[3].push_back(Utils::QUAL_NOPERSPECTIVE); 6439 m_test_cases[3].push_back(Utils::QUAL_INVARIANT); 6440 6441 return true; 6442 } 6443 6444 /** Returns reference to current test case 6445 * 6446 * @return Reference to testCase 6447 **/ 6448 const Utils::qualifierSet& QualifierOrderBlockTest::getCurrentTestCase() 6449 { 6450 if ((glw::GLuint)-1 == m_current_test_case_index) 6451 { 6452 return m_test_cases[0]; 6453 } 6454 else 6455 { 6456 return m_test_cases[m_current_test_case_index]; 6457 } 6458 } 6459 6460 /** Constructor 6461 * 6462 * @param context Test context 6463 **/ 6464 QualifierOrderUniformTest::QualifierOrderUniformTest(deqp::Context& context) 6465 : GLSLTestBase(context, "qualifier_order_uniform", 6466 "Test verifies that all valid permutation of input qalifiers are accepted") 6467 { 6468 /* Nothing to be done here */ 6469 } 6470 6471 /** Set up next test case 6472 * 6473 * @param test_case_index Index of next test case 6474 * 6475 * @return false if there is no more test cases, true otherwise 6476 **/ 6477 bool QualifierOrderUniformTest::prepareNextTestCase(glw::GLuint test_case_index) 6478 { 6479 m_current_test_case_index = test_case_index; 6480 6481 if ((glw::GLuint)-1 == test_case_index) 6482 { 6483 /* Nothing to be done here */; 6484 } 6485 else if (m_test_cases.size() <= test_case_index) 6486 { 6487 return false; 6488 } 6489 6490 const Utils::qualifierSet& set = getCurrentTestCase(); 6491 6492 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 6493 6494 for (GLuint i = 0; i < set.size(); ++i) 6495 { 6496 message << Utils::getQualifierString(set[i]) << " "; 6497 } 6498 6499 message << tcu::TestLog::EndMessage; 6500 6501 return true; 6502 } 6503 6504 /** Prepare source for given shader stage 6505 * 6506 * @param in_stage Shader stage, compute shader will use 430 6507 * @param in_use_version_400 Select if 400 or 420 should be used 6508 * @param out_source Prepared shader source instance 6509 **/ 6510 void QualifierOrderUniformTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 6511 Utils::shaderSource& out_source) 6512 { 6513 static const GLchar* verification_snippet = 6514 " vec4 diff = VARIABLE_NAME - vec4(0, 0, 1, 1);\n" 6515 " if (false == all(lessThan(diff, vec4(0.001, 0.001, 0.001, 0.001))))\n" 6516 " {\n" 6517 " result = VARIABLE_NAME;\n" 6518 " }\n"; 6519 6520 static const GLchar* variable_declaration = " QUALIFIERS VARIABLE_NAME"; 6521 6522 static const GLchar* fragment_shader_template = "VERSION\n" 6523 "#extension GL_ARB_explicit_uniform_location : enable\n" 6524 "\n" 6525 "in vec4 gs_fs_result;\n" 6526 "out vec4 fs_out_result;\n" 6527 "\n" 6528 "VARIABLE_DECLARATION;\n" 6529 "\n" 6530 "void main()\n" 6531 "{\n" 6532 " vec4 result = vec4(0, 1, 0, 1);\n" 6533 "\n" 6534 "VERIFICATION" 6535 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 6536 " {\n" 6537 " result = vec4(1, 0, 0, 1);\n" 6538 " }\n" 6539 "\n" 6540 " fs_out_result = result;\n" 6541 "}\n" 6542 "\n"; 6543 6544 static const GLchar* geometry_shader_template = "VERSION\n" 6545 "#extension GL_ARB_explicit_uniform_location : enable\n" 6546 "\n" 6547 "layout(points) in;\n" 6548 "layout(triangle_strip, max_vertices = 4) out;\n" 6549 "\n" 6550 "in vec4 tes_gs_result[];\n" 6551 "out vec4 gs_fs_result;\n" 6552 "\n" 6553 "VARIABLE_DECLARATION;\n" 6554 "\n" 6555 "void main()\n" 6556 "{\n" 6557 " vec4 result = vec4(0, 1, 0, 1);\n" 6558 "\n" 6559 "VERIFICATION" 6560 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 6561 " {\n" 6562 " result = vec4(1, 0, 0, 1);\n" 6563 " }\n" 6564 "\n" 6565 " gs_fs_result = result;\n" 6566 " gl_Position = vec4(-1, -1, 0, 1);\n" 6567 " EmitVertex();\n" 6568 " gs_fs_result = result;\n" 6569 " gl_Position = vec4(-1, 1, 0, 1);\n" 6570 " EmitVertex();\n" 6571 " gs_fs_result = result;\n" 6572 " gl_Position = vec4(1, -1, 0, 1);\n" 6573 " EmitVertex();\n" 6574 " gs_fs_result = result;\n" 6575 " gl_Position = vec4(1, 1, 0, 1);\n" 6576 " EmitVertex();\n" 6577 "}\n" 6578 "\n"; 6579 6580 static const GLchar* tess_ctrl_shader_template = 6581 "VERSION\n" 6582 "#extension GL_ARB_explicit_uniform_location : enable\n" 6583 "\n" 6584 "layout(vertices = 1) out;\n" 6585 "\n" 6586 "in vec4 vs_tcs_result[];\n" 6587 "out vec4 tcs_tes_result[];\n" 6588 "\n" 6589 "VARIABLE_DECLARATION;\n" 6590 "\n" 6591 "void main()\n" 6592 "{\n" 6593 " vec4 result = vec4(0, 1, 0, 1);\n" 6594 "\n" 6595 "VERIFICATION" 6596 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 6597 " {\n" 6598 " result = vec4(1, 0, 0, 1);\n" 6599 " }\n" 6600 "\n" 6601 " tcs_tes_result[gl_InvocationID] = result;\n" 6602 "\n" 6603 " gl_TessLevelOuter[0] = 1.0;\n" 6604 " gl_TessLevelOuter[1] = 1.0;\n" 6605 " gl_TessLevelOuter[2] = 1.0;\n" 6606 " gl_TessLevelOuter[3] = 1.0;\n" 6607 " gl_TessLevelInner[0] = 1.0;\n" 6608 " gl_TessLevelInner[1] = 1.0;\n" 6609 "}\n" 6610 "\n"; 6611 6612 static const GLchar* tess_eval_shader_template = "VERSION\n" 6613 "#extension GL_ARB_explicit_uniform_location : enable\n" 6614 "\n" 6615 "layout(isolines, point_mode) in;\n" 6616 "\n" 6617 "in vec4 tcs_tes_result[];\n" 6618 "out vec4 tes_gs_result;\n" 6619 "\n" 6620 "VARIABLE_DECLARATION;\n" 6621 "\n" 6622 "void main()\n" 6623 "{\n" 6624 " vec4 result = vec4(0, 1, 0, 1);\n" 6625 "\n" 6626 "VERIFICATION" 6627 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 6628 " {\n" 6629 " result = vec4(1, 0, 0, 1);\n" 6630 " }\n" 6631 "\n" 6632 " tes_gs_result = result;\n" 6633 "}\n" 6634 "\n"; 6635 6636 static const GLchar* vertex_shader_template = "VERSION\n" 6637 "#extension GL_ARB_explicit_uniform_location : enable\n" 6638 "\n" 6639 "out vec4 vs_tcs_result;\n" 6640 "\n" 6641 "VARIABLE_DECLARATION;\n" 6642 "\n" 6643 "void main()\n" 6644 "{\n" 6645 " vec4 result = vec4(0, 1, 0, 1);\n" 6646 "\n" 6647 "VERIFICATION" 6648 "\n" 6649 " vs_tcs_result = result;\n" 6650 "}\n" 6651 "\n"; 6652 6653 const GLchar* shader_template = 0; 6654 const GLchar* location_string = 0; 6655 6656 switch (in_stage) 6657 { 6658 case Utils::COMPUTE_SHADER: 6659 return; 6660 break; 6661 case Utils::FRAGMENT_SHADER: 6662 shader_template = fragment_shader_template; 6663 location_string = "0"; 6664 break; 6665 case Utils::GEOMETRY_SHADER: 6666 shader_template = geometry_shader_template; 6667 location_string = "1"; 6668 break; 6669 case Utils::TESS_CTRL_SHADER: 6670 shader_template = tess_ctrl_shader_template; 6671 location_string = "4"; 6672 break; 6673 case Utils::TESS_EVAL_SHADER: 6674 shader_template = tess_eval_shader_template; 6675 location_string = "3"; 6676 break; 6677 case Utils::VERTEX_SHADER: 6678 shader_template = vertex_shader_template; 6679 location_string = "2"; 6680 break; 6681 default: 6682 TCU_FAIL("Invalid enum"); 6683 break; 6684 } 6685 6686 const Utils::qualifierSet& test_case = getCurrentTestCase(); 6687 6688 std::string uni_declaration; 6689 std::string uni_reference; 6690 Utils::prepareVariableStrings(in_stage, Utils::UNIFORM, test_case, "vec4", "test", uni_declaration, uni_reference); 6691 6692 out_source.m_parts[0].m_code = shader_template; 6693 6694 size_t position = 0; 6695 6696 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 6697 out_source.m_parts[0].m_code); 6698 6699 Utils::replaceToken("VARIABLE_DECLARATION", position, uni_declaration.c_str(), out_source.m_parts[0].m_code); 6700 6701 position -= strlen(variable_declaration); 6702 6703 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 6704 6705 Utils::replaceAllTokens("VARIABLE_NAME", uni_reference.c_str(), out_source.m_parts[0].m_code); 6706 6707 Utils::replaceAllTokens("LOC_VALUE", location_string, out_source.m_parts[0].m_code); 6708 } 6709 6710 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 6711 * 6712 * @param program Current program 6713 **/ 6714 void QualifierOrderUniformTest::prepareUniforms(Utils::program& program) 6715 { 6716 static const GLfloat float_data[4] = { 0.0f, 0.0f, 1.0f, 1.0f }; 6717 6718 program.uniform("uni_fs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 6719 program.uniform("uni_gs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 6720 program.uniform("uni_tcs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 6721 program.uniform("uni_tes_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 6722 program.uniform("uni_vs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 6723 } 6724 6725 /** Prepare test cases 6726 * 6727 * @return false if ARB_explicit_uniform_location is not supported, true otherwise 6728 **/ 6729 bool QualifierOrderUniformTest::testInit() 6730 { 6731 if (false == m_is_explicit_uniform_location) 6732 { 6733 return false; 6734 } 6735 6736 m_test_cases.resize(4); 6737 6738 m_test_cases[0].push_back(Utils::QUAL_HIGHP); 6739 m_test_cases[0].push_back(Utils::QUAL_UNIFORM); 6740 m_test_cases[0].push_back(Utils::QUAL_LOCATION); 6741 6742 m_test_cases[1].push_back(Utils::QUAL_LOWP); 6743 m_test_cases[1].push_back(Utils::QUAL_UNIFORM); 6744 m_test_cases[1].push_back(Utils::QUAL_LOCATION); 6745 6746 m_test_cases[2].push_back(Utils::QUAL_HIGHP); 6747 m_test_cases[2].push_back(Utils::QUAL_LOCATION); 6748 m_test_cases[2].push_back(Utils::QUAL_UNIFORM); 6749 m_test_cases[2].push_back(Utils::QUAL_LOCATION); 6750 6751 m_test_cases[3].push_back(Utils::QUAL_LOCATION); 6752 m_test_cases[3].push_back(Utils::QUAL_LOWP); 6753 m_test_cases[3].push_back(Utils::QUAL_UNIFORM); 6754 m_test_cases[3].push_back(Utils::QUAL_LOCATION); 6755 6756 return true; 6757 } 6758 6759 /** Returns reference to current test case 6760 * 6761 * @return Reference to testCase 6762 **/ 6763 const Utils::qualifierSet& QualifierOrderUniformTest::getCurrentTestCase() 6764 { 6765 if ((glw::GLuint)-1 == m_current_test_case_index) 6766 { 6767 return m_test_cases[0]; 6768 } 6769 else 6770 { 6771 return m_test_cases[m_current_test_case_index]; 6772 } 6773 } 6774 6775 /** Constructor 6776 * 6777 * @param context Test context 6778 **/ 6779 QualifierOrderFunctionInoutTest::QualifierOrderFunctionInoutTest(deqp::Context& context) 6780 : GLSLTestBase(context, "qualifier_order_function_inout", "Verify order of qualifiers of inout function parameters") 6781 { 6782 /* Nothing to be done here */ 6783 } 6784 6785 /** Set up next test case 6786 * 6787 * @param test_case_index Index of next test case 6788 * 6789 * @return false if there is no more test cases, true otherwise 6790 **/ 6791 bool QualifierOrderFunctionInoutTest::prepareNextTestCase(glw::GLuint test_case_index) 6792 { 6793 m_current_test_case_index = test_case_index; 6794 6795 if ((glw::GLuint)-1 == test_case_index) 6796 { 6797 /* Nothing to be done here */; 6798 } 6799 else if (m_test_cases.size() <= test_case_index) 6800 { 6801 return false; 6802 } 6803 6804 const Utils::qualifierSet& set = getCurrentTestCase(); 6805 6806 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 6807 6808 for (GLuint i = 0; i < set.size(); ++i) 6809 { 6810 message << Utils::getQualifierString(set[i]) << " "; 6811 } 6812 6813 message << tcu::TestLog::EndMessage; 6814 6815 return true; 6816 } 6817 6818 /** Prepare source for given shader stage 6819 * 6820 * @param in_stage Shader stage, compute shader will use 430 6821 * @param in_use_version_400 Select if 400 or 420 should be used 6822 * @param out_source Prepared shader source instance 6823 **/ 6824 void QualifierOrderFunctionInoutTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 6825 Utils::shaderSource& out_source) 6826 { 6827 static const GLchar* verification_snippet = 6828 " vec4 temp = VARIABLE_NAME;\n" 6829 "\n" 6830 " function(temp);\n" 6831 "\n" 6832 " vec4 diff = temp - vec4(0, 0, 1, 1);\n" 6833 " if (false == all(lessThan(diff, vec4(0.001, 0.001, 0.001, 0.001))))\n" 6834 " {\n" 6835 " result = VARIABLE_NAME;\n" 6836 " }\n"; 6837 6838 static const GLchar* function_declaration = "void function(QUALIFIERS_LIST vec4 param)\n" 6839 "{\n" 6840 " param = param.wzyx;\n" 6841 "}\n"; 6842 6843 static const GLchar* fragment_shader_template = "VERSION\n" 6844 "\n" 6845 "in vec4 gs_fs_result;\n" 6846 "out vec4 fs_out_result;\n" 6847 "\n" 6848 "uniform vec4 VARIABLE_NAME;\n" 6849 "\n" 6850 "FUNCTION_DECLARATION\n" 6851 "\n" 6852 "void main()\n" 6853 "{\n" 6854 " vec4 result = vec4(0, 1, 0, 1);\n" 6855 "\n" 6856 "VERIFICATION" 6857 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 6858 " {\n" 6859 " result = vec4(1, 0, 0, 1);\n" 6860 " }\n" 6861 "\n" 6862 " fs_out_result = result;\n" 6863 "}\n" 6864 "\n"; 6865 6866 static const GLchar* geometry_shader_template = "VERSION\n" 6867 "\n" 6868 "layout(points) in;\n" 6869 "layout(triangle_strip, max_vertices = 4) out;\n" 6870 "\n" 6871 "in vec4 tes_gs_result[];\n" 6872 "out vec4 gs_fs_result;\n" 6873 "\n" 6874 "uniform vec4 VARIABLE_NAME;\n" 6875 "\n" 6876 "FUNCTION_DECLARATION\n" 6877 "\n" 6878 "void main()\n" 6879 "{\n" 6880 " vec4 result = vec4(0, 1, 0, 1);\n" 6881 "\n" 6882 "VERIFICATION" 6883 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 6884 " {\n" 6885 " result = vec4(1, 0, 0, 1);\n" 6886 " }\n" 6887 "\n" 6888 " gs_fs_result = result;\n" 6889 " gl_Position = vec4(-1, -1, 0, 1);\n" 6890 " EmitVertex();\n" 6891 " gs_fs_result = result;\n" 6892 " gl_Position = vec4(-1, 1, 0, 1);\n" 6893 " EmitVertex();\n" 6894 " gs_fs_result = result;\n" 6895 " gl_Position = vec4(1, -1, 0, 1);\n" 6896 " EmitVertex();\n" 6897 " gs_fs_result = result;\n" 6898 " gl_Position = vec4(1, 1, 0, 1);\n" 6899 " EmitVertex();\n" 6900 "}\n" 6901 "\n"; 6902 6903 static const GLchar* tess_ctrl_shader_template = 6904 "VERSION\n" 6905 "\n" 6906 "layout(vertices = 1) out;\n" 6907 "\n" 6908 "in vec4 vs_tcs_result[];\n" 6909 "out vec4 tcs_tes_result[];\n" 6910 "\n" 6911 "uniform vec4 VARIABLE_NAME;\n" 6912 "\n" 6913 "FUNCTION_DECLARATION\n" 6914 "\n" 6915 "void main()\n" 6916 "{\n" 6917 " vec4 result = vec4(0, 1, 0, 1);\n" 6918 "\n" 6919 "VERIFICATION" 6920 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 6921 " {\n" 6922 " result = vec4(1, 0, 0, 1);\n" 6923 " }\n" 6924 "\n" 6925 " tcs_tes_result[gl_InvocationID] = result;\n" 6926 "\n" 6927 " gl_TessLevelOuter[0] = 1.0;\n" 6928 " gl_TessLevelOuter[1] = 1.0;\n" 6929 " gl_TessLevelOuter[2] = 1.0;\n" 6930 " gl_TessLevelOuter[3] = 1.0;\n" 6931 " gl_TessLevelInner[0] = 1.0;\n" 6932 " gl_TessLevelInner[1] = 1.0;\n" 6933 "}\n" 6934 "\n"; 6935 6936 static const GLchar* tess_eval_shader_template = "VERSION\n" 6937 "\n" 6938 "layout(isolines, point_mode) in;\n" 6939 "\n" 6940 "in vec4 tcs_tes_result[];\n" 6941 "out vec4 tes_gs_result;\n" 6942 "\n" 6943 "uniform vec4 VARIABLE_NAME;\n" 6944 "\n" 6945 "FUNCTION_DECLARATION\n" 6946 "\n" 6947 "void main()\n" 6948 "{\n" 6949 " vec4 result = vec4(0, 1, 0, 1);\n" 6950 "\n" 6951 "VERIFICATION" 6952 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 6953 " {\n" 6954 " result = vec4(1, 0, 0, 1);\n" 6955 " }\n" 6956 "\n" 6957 " tes_gs_result = result;\n" 6958 "}\n" 6959 "\n"; 6960 6961 static const GLchar* vertex_shader_template = "VERSION\n" 6962 "\n" 6963 "out vec4 vs_tcs_result;\n" 6964 "\n" 6965 "uniform vec4 VARIABLE_NAME;\n" 6966 "\n" 6967 "FUNCTION_DECLARATION\n" 6968 "\n" 6969 "void main()\n" 6970 "{\n" 6971 " vec4 result = vec4(0, 1, 0, 1);\n" 6972 "\n" 6973 "VERIFICATION" 6974 "\n" 6975 " vs_tcs_result = result;\n" 6976 "}\n" 6977 "\n"; 6978 6979 const GLchar* shader_template = 0; 6980 6981 switch (in_stage) 6982 { 6983 case Utils::COMPUTE_SHADER: 6984 return; 6985 break; 6986 case Utils::FRAGMENT_SHADER: 6987 shader_template = fragment_shader_template; 6988 break; 6989 case Utils::GEOMETRY_SHADER: 6990 shader_template = geometry_shader_template; 6991 break; 6992 case Utils::TESS_CTRL_SHADER: 6993 shader_template = tess_ctrl_shader_template; 6994 break; 6995 case Utils::TESS_EVAL_SHADER: 6996 shader_template = tess_eval_shader_template; 6997 break; 6998 case Utils::VERTEX_SHADER: 6999 shader_template = vertex_shader_template; 7000 break; 7001 default: 7002 TCU_FAIL("Invalid enum"); 7003 break; 7004 } 7005 7006 const std::string& uni_reference = Utils::getVariableName(in_stage, Utils::UNIFORM, "test"); 7007 const std::string& qualifier_list = Utils::getQualifiersListString(getCurrentTestCase()); 7008 7009 out_source.m_parts[0].m_code = shader_template; 7010 7011 size_t position = 0; 7012 7013 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 7014 out_source.m_parts[0].m_code); 7015 7016 Utils::replaceToken("FUNCTION_DECLARATION", position, function_declaration, out_source.m_parts[0].m_code); 7017 7018 position -= strlen(function_declaration); 7019 7020 Utils::replaceToken("QUALIFIERS_LIST", position, qualifier_list.c_str(), out_source.m_parts[0].m_code); 7021 7022 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 7023 7024 Utils::replaceAllTokens("VARIABLE_NAME", uni_reference.c_str(), out_source.m_parts[0].m_code); 7025 } 7026 7027 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 7028 * 7029 * @param program Current program 7030 **/ 7031 void QualifierOrderFunctionInoutTest::prepareUniforms(Utils::program& program) 7032 { 7033 static const GLfloat float_data[4] = { 1.0f, 1.0f, 0.0f, 0.0f }; 7034 7035 program.uniform("uni_fs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7036 program.uniform("uni_gs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7037 program.uniform("uni_tcs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7038 program.uniform("uni_tes_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7039 program.uniform("uni_vs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7040 } 7041 7042 /** Prepare test cases 7043 * 7044 * @return false if ARB_explicit_uniform_location is not supported, true otherwise 7045 **/ 7046 bool QualifierOrderFunctionInoutTest::testInit() 7047 { 7048 m_test_cases.resize(6); 7049 7050 m_test_cases[0].push_back(Utils::QUAL_HIGHP); 7051 m_test_cases[0].push_back(Utils::QUAL_PRECISE); 7052 m_test_cases[0].push_back(Utils::QUAL_INOUT); 7053 7054 m_test_cases[1].push_back(Utils::QUAL_INOUT); 7055 m_test_cases[1].push_back(Utils::QUAL_PRECISE); 7056 m_test_cases[1].push_back(Utils::QUAL_HIGHP); 7057 7058 m_test_cases[2].push_back(Utils::QUAL_MEDIUMP); 7059 m_test_cases[2].push_back(Utils::QUAL_PRECISE); 7060 m_test_cases[2].push_back(Utils::QUAL_INOUT); 7061 7062 m_test_cases[3].push_back(Utils::QUAL_INOUT); 7063 m_test_cases[3].push_back(Utils::QUAL_PRECISE); 7064 m_test_cases[3].push_back(Utils::QUAL_MEDIUMP); 7065 7066 m_test_cases[4].push_back(Utils::QUAL_LOWP); 7067 m_test_cases[4].push_back(Utils::QUAL_PRECISE); 7068 m_test_cases[4].push_back(Utils::QUAL_INOUT); 7069 7070 m_test_cases[5].push_back(Utils::QUAL_INOUT); 7071 m_test_cases[5].push_back(Utils::QUAL_PRECISE); 7072 m_test_cases[5].push_back(Utils::QUAL_LOWP); 7073 7074 return true; 7075 } 7076 7077 /** Returns reference to current test case 7078 * 7079 * @return Reference to testCase 7080 **/ 7081 const Utils::qualifierSet& QualifierOrderFunctionInoutTest::getCurrentTestCase() 7082 { 7083 if ((glw::GLuint)-1 == m_current_test_case_index) 7084 { 7085 return m_test_cases[0]; 7086 } 7087 else 7088 { 7089 return m_test_cases[m_current_test_case_index]; 7090 } 7091 } 7092 7093 /** Constructor 7094 * 7095 * @param context Test context 7096 **/ 7097 QualifierOrderFunctionInputTest::QualifierOrderFunctionInputTest(deqp::Context& context) 7098 : GLSLTestBase(context, "qualifier_order_function_input", "Verify order of qualifiers of function input parameters") 7099 { 7100 /* Nothing to be done here */ 7101 } 7102 7103 /** Set up next test case 7104 * 7105 * @param test_case_index Index of next test case 7106 * 7107 * @return false if there is no more test cases, true otherwise 7108 **/ 7109 bool QualifierOrderFunctionInputTest::prepareNextTestCase(glw::GLuint test_case_index) 7110 { 7111 m_current_test_case_index = test_case_index; 7112 7113 if ((glw::GLuint)-1 == test_case_index) 7114 { 7115 /* Nothing to be done here */; 7116 } 7117 else if (m_test_cases.size() <= test_case_index) 7118 { 7119 return false; 7120 } 7121 7122 const Utils::qualifierSet& set = getCurrentTestCase(); 7123 7124 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 7125 7126 for (GLuint i = 0; i < set.size(); ++i) 7127 { 7128 message << Utils::getQualifierString(set[i]) << " "; 7129 } 7130 7131 message << tcu::TestLog::EndMessage; 7132 7133 return true; 7134 } 7135 7136 /** Prepare source for given shader stage 7137 * 7138 * @param in_stage Shader stage, compute shader will use 430 7139 * @param in_use_version_400 Select if 400 or 420 should be used 7140 * @param out_source Prepared shader source instance 7141 **/ 7142 void QualifierOrderFunctionInputTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 7143 Utils::shaderSource& out_source) 7144 { 7145 static const GLchar* verification_snippet = 7146 " vec4 temp = function(VARIABLE_NAME);\n" 7147 "\n" 7148 " vec4 diff = temp - vec4(0, 0, 1, 1);\n" 7149 " if (false == all(lessThan(diff, vec4(0.001, 0.001, 0.001, 0.001))))\n" 7150 " {\n" 7151 " result = VARIABLE_NAME;\n" 7152 " }\n"; 7153 7154 static const GLchar* function_declaration = "vec4 function(QUALIFIERS_LIST vec4 param)\n" 7155 "{\n" 7156 " return param.wzyx;\n" 7157 "}\n"; 7158 7159 static const GLchar* fragment_shader_template = "VERSION\n" 7160 "\n" 7161 "in vec4 gs_fs_result;\n" 7162 "out vec4 fs_out_result;\n" 7163 "\n" 7164 "uniform vec4 VARIABLE_NAME;\n" 7165 "\n" 7166 "FUNCTION_DECLARATION\n" 7167 "\n" 7168 "void main()\n" 7169 "{\n" 7170 " vec4 result = vec4(0, 1, 0, 1);\n" 7171 "\n" 7172 "VERIFICATION" 7173 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 7174 " {\n" 7175 " result = vec4(1, 0, 0, 1);\n" 7176 " }\n" 7177 "\n" 7178 " fs_out_result = result;\n" 7179 "}\n" 7180 "\n"; 7181 7182 static const GLchar* geometry_shader_template = "VERSION\n" 7183 "\n" 7184 "layout(points) in;\n" 7185 "layout(triangle_strip, max_vertices = 4) out;\n" 7186 "\n" 7187 "in vec4 tes_gs_result[];\n" 7188 "out vec4 gs_fs_result;\n" 7189 "\n" 7190 "uniform vec4 VARIABLE_NAME;\n" 7191 "\n" 7192 "FUNCTION_DECLARATION\n" 7193 "\n" 7194 "void main()\n" 7195 "{\n" 7196 " vec4 result = vec4(0, 1, 0, 1);\n" 7197 "\n" 7198 "VERIFICATION" 7199 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 7200 " {\n" 7201 " result = vec4(1, 0, 0, 1);\n" 7202 " }\n" 7203 "\n" 7204 " gs_fs_result = result;\n" 7205 " gl_Position = vec4(-1, -1, 0, 1);\n" 7206 " EmitVertex();\n" 7207 " gs_fs_result = result;\n" 7208 " gl_Position = vec4(-1, 1, 0, 1);\n" 7209 " EmitVertex();\n" 7210 " gs_fs_result = result;\n" 7211 " gl_Position = vec4(1, -1, 0, 1);\n" 7212 " EmitVertex();\n" 7213 " gs_fs_result = result;\n" 7214 " gl_Position = vec4(1, 1, 0, 1);\n" 7215 " EmitVertex();\n" 7216 "}\n" 7217 "\n"; 7218 7219 static const GLchar* tess_ctrl_shader_template = 7220 "VERSION\n" 7221 "\n" 7222 "layout(vertices = 1) out;\n" 7223 "\n" 7224 "in vec4 vs_tcs_result[];\n" 7225 "out vec4 tcs_tes_result[];\n" 7226 "\n" 7227 "uniform vec4 VARIABLE_NAME;\n" 7228 "\n" 7229 "FUNCTION_DECLARATION\n" 7230 "\n" 7231 "void main()\n" 7232 "{\n" 7233 " vec4 result = vec4(0, 1, 0, 1);\n" 7234 "\n" 7235 "VERIFICATION" 7236 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 7237 " {\n" 7238 " result = vec4(1, 0, 0, 1);\n" 7239 " }\n" 7240 "\n" 7241 " tcs_tes_result[gl_InvocationID] = result;\n" 7242 "\n" 7243 " gl_TessLevelOuter[0] = 1.0;\n" 7244 " gl_TessLevelOuter[1] = 1.0;\n" 7245 " gl_TessLevelOuter[2] = 1.0;\n" 7246 " gl_TessLevelOuter[3] = 1.0;\n" 7247 " gl_TessLevelInner[0] = 1.0;\n" 7248 " gl_TessLevelInner[1] = 1.0;\n" 7249 "}\n" 7250 "\n"; 7251 7252 static const GLchar* tess_eval_shader_template = "VERSION\n" 7253 "\n" 7254 "layout(isolines, point_mode) in;\n" 7255 "\n" 7256 "in vec4 tcs_tes_result[];\n" 7257 "out vec4 tes_gs_result;\n" 7258 "\n" 7259 "uniform vec4 VARIABLE_NAME;\n" 7260 "\n" 7261 "FUNCTION_DECLARATION\n" 7262 "\n" 7263 "void main()\n" 7264 "{\n" 7265 " vec4 result = vec4(0, 1, 0, 1);\n" 7266 "\n" 7267 "VERIFICATION" 7268 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 7269 " {\n" 7270 " result = vec4(1, 0, 0, 1);\n" 7271 " }\n" 7272 "\n" 7273 " tes_gs_result = result;\n" 7274 "}\n" 7275 "\n"; 7276 7277 static const GLchar* vertex_shader_template = "VERSION\n" 7278 "\n" 7279 "out vec4 vs_tcs_result;\n" 7280 "\n" 7281 "uniform vec4 VARIABLE_NAME;\n" 7282 "\n" 7283 "FUNCTION_DECLARATION\n" 7284 "\n" 7285 "void main()\n" 7286 "{\n" 7287 " vec4 result = vec4(0, 1, 0, 1);\n" 7288 "\n" 7289 "VERIFICATION" 7290 "\n" 7291 " vs_tcs_result = result;\n" 7292 "}\n" 7293 "\n"; 7294 7295 const GLchar* shader_template = 0; 7296 7297 switch (in_stage) 7298 { 7299 case Utils::COMPUTE_SHADER: 7300 return; 7301 break; 7302 case Utils::FRAGMENT_SHADER: 7303 shader_template = fragment_shader_template; 7304 break; 7305 case Utils::GEOMETRY_SHADER: 7306 shader_template = geometry_shader_template; 7307 break; 7308 case Utils::TESS_CTRL_SHADER: 7309 shader_template = tess_ctrl_shader_template; 7310 break; 7311 case Utils::TESS_EVAL_SHADER: 7312 shader_template = tess_eval_shader_template; 7313 break; 7314 case Utils::VERTEX_SHADER: 7315 shader_template = vertex_shader_template; 7316 break; 7317 default: 7318 TCU_FAIL("Invalid enum"); 7319 break; 7320 } 7321 7322 const std::string& uni_reference = Utils::getVariableName(in_stage, Utils::UNIFORM, "test"); 7323 const std::string& qualifier_list = Utils::getQualifiersListString(getCurrentTestCase()); 7324 7325 out_source.m_parts[0].m_code = shader_template; 7326 7327 size_t position = 0; 7328 7329 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 7330 out_source.m_parts[0].m_code); 7331 7332 Utils::replaceToken("FUNCTION_DECLARATION", position, function_declaration, out_source.m_parts[0].m_code); 7333 7334 position -= strlen(function_declaration); 7335 7336 Utils::replaceToken("QUALIFIERS_LIST", position, qualifier_list.c_str(), out_source.m_parts[0].m_code); 7337 7338 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 7339 7340 Utils::replaceAllTokens("VARIABLE_NAME", uni_reference.c_str(), out_source.m_parts[0].m_code); 7341 } 7342 7343 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 7344 * 7345 * @param program Current program 7346 **/ 7347 void QualifierOrderFunctionInputTest::prepareUniforms(Utils::program& program) 7348 { 7349 static const GLfloat float_data[4] = { 1.0f, 1.0f, 0.0f, 0.0f }; 7350 7351 program.uniform("uni_fs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7352 program.uniform("uni_gs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7353 program.uniform("uni_tcs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7354 program.uniform("uni_tes_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7355 program.uniform("uni_vs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7356 } 7357 7358 /** Prepare test cases 7359 * 7360 * @return false if ARB_explicit_uniform_location is not supported, true otherwise 7361 **/ 7362 bool QualifierOrderFunctionInputTest::testInit() 7363 { 7364 m_test_cases.resize(6); 7365 7366 m_test_cases[0].push_back(Utils::QUAL_CONST); 7367 m_test_cases[0].push_back(Utils::QUAL_HIGHP); 7368 m_test_cases[0].push_back(Utils::QUAL_PRECISE); 7369 m_test_cases[0].push_back(Utils::QUAL_IN); 7370 7371 m_test_cases[1].push_back(Utils::QUAL_IN); 7372 m_test_cases[1].push_back(Utils::QUAL_CONST); 7373 m_test_cases[1].push_back(Utils::QUAL_PRECISE); 7374 m_test_cases[1].push_back(Utils::QUAL_HIGHP); 7375 7376 m_test_cases[2].push_back(Utils::QUAL_PRECISE); 7377 m_test_cases[2].push_back(Utils::QUAL_MEDIUMP); 7378 m_test_cases[2].push_back(Utils::QUAL_CONST); 7379 m_test_cases[2].push_back(Utils::QUAL_IN); 7380 7381 m_test_cases[3].push_back(Utils::QUAL_IN); 7382 m_test_cases[3].push_back(Utils::QUAL_PRECISE); 7383 m_test_cases[3].push_back(Utils::QUAL_MEDIUMP); 7384 m_test_cases[3].push_back(Utils::QUAL_CONST); 7385 7386 m_test_cases[4].push_back(Utils::QUAL_LOWP); 7387 m_test_cases[4].push_back(Utils::QUAL_CONST); 7388 m_test_cases[4].push_back(Utils::QUAL_IN); 7389 m_test_cases[4].push_back(Utils::QUAL_PRECISE); 7390 7391 m_test_cases[5].push_back(Utils::QUAL_IN); 7392 m_test_cases[5].push_back(Utils::QUAL_PRECISE); 7393 m_test_cases[5].push_back(Utils::QUAL_CONST); 7394 m_test_cases[5].push_back(Utils::QUAL_LOWP); 7395 7396 return true; 7397 } 7398 7399 /** Returns reference to current test case 7400 * 7401 * @return Reference to testCase 7402 **/ 7403 const Utils::qualifierSet& QualifierOrderFunctionInputTest::getCurrentTestCase() 7404 { 7405 if ((glw::GLuint)-1 == m_current_test_case_index) 7406 { 7407 return m_test_cases[0]; 7408 } 7409 else 7410 { 7411 return m_test_cases[m_current_test_case_index]; 7412 } 7413 } 7414 7415 /** Constructor 7416 * 7417 * @param context Test context 7418 **/ 7419 QualifierOrderFunctionOutputTest::QualifierOrderFunctionOutputTest(deqp::Context& context) 7420 : GLSLTestBase(context, "qualifier_order_function_output", 7421 "Verify order of qualifiers of output function parameters") 7422 { 7423 /* Nothing to be done here */ 7424 } 7425 7426 /** Set up next test case 7427 * 7428 * @param test_case_index Index of next test case 7429 * 7430 * @return false if there is no more test cases, true otherwise 7431 **/ 7432 bool QualifierOrderFunctionOutputTest::prepareNextTestCase(glw::GLuint test_case_index) 7433 { 7434 m_current_test_case_index = test_case_index; 7435 7436 if ((glw::GLuint)-1 == test_case_index) 7437 { 7438 /* Nothing to be done here */; 7439 } 7440 else if (m_test_cases.size() <= test_case_index) 7441 { 7442 return false; 7443 } 7444 7445 const Utils::qualifierSet& set = getCurrentTestCase(); 7446 7447 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 7448 7449 for (GLuint i = 0; i < set.size(); ++i) 7450 { 7451 message << Utils::getQualifierString(set[i]) << " "; 7452 } 7453 7454 message << tcu::TestLog::EndMessage; 7455 7456 return true; 7457 } 7458 7459 /** Prepare source for given shader stage 7460 * 7461 * @param in_stage Shader stage, compute shader will use 430 7462 * @param in_use_version_400 Select if 400 or 420 should be used 7463 * @param out_source Prepared shader source instance 7464 **/ 7465 void QualifierOrderFunctionOutputTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 7466 Utils::shaderSource& out_source) 7467 { 7468 static const GLchar* verification_snippet = 7469 " vec4 temp;\n" 7470 "\n" 7471 " function(temp);\n" 7472 "\n" 7473 " vec4 diff = temp - vec4(0, 0, 1, 1);\n" 7474 " if (false == all(lessThan(diff, vec4(0.001, 0.001, 0.001, 0.001))))\n" 7475 " {\n" 7476 " result = VARIABLE_NAME;\n" 7477 " }\n"; 7478 7479 static const GLchar* function_declaration = "void function(QUALIFIERS_LIST vec4 param)\n" 7480 "{\n" 7481 " param = VARIABLE_NAME.wzyx;\n" 7482 "}\n"; 7483 7484 static const GLchar* fragment_shader_template = "VERSION\n" 7485 "\n" 7486 "in vec4 gs_fs_result;\n" 7487 "out vec4 fs_out_result;\n" 7488 "\n" 7489 "uniform vec4 VARIABLE_NAME;\n" 7490 "\n" 7491 "FUNCTION_DECLARATION\n" 7492 "\n" 7493 "void main()\n" 7494 "{\n" 7495 " vec4 result = vec4(0, 1, 0, 1);\n" 7496 "\n" 7497 "VERIFICATION" 7498 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 7499 " {\n" 7500 " result = vec4(1, 0, 0, 1);\n" 7501 " }\n" 7502 "\n" 7503 " fs_out_result = result;\n" 7504 "}\n" 7505 "\n"; 7506 7507 static const GLchar* geometry_shader_template = "VERSION\n" 7508 "\n" 7509 "layout(points) in;\n" 7510 "layout(triangle_strip, max_vertices = 4) out;\n" 7511 "\n" 7512 "in vec4 tes_gs_result[];\n" 7513 "out vec4 gs_fs_result;\n" 7514 "\n" 7515 "uniform vec4 VARIABLE_NAME;\n" 7516 "\n" 7517 "FUNCTION_DECLARATION\n" 7518 "\n" 7519 "void main()\n" 7520 "{\n" 7521 " vec4 result = vec4(0, 1, 0, 1);\n" 7522 "\n" 7523 "VERIFICATION" 7524 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 7525 " {\n" 7526 " result = vec4(1, 0, 0, 1);\n" 7527 " }\n" 7528 "\n" 7529 " gs_fs_result = result;\n" 7530 " gl_Position = vec4(-1, -1, 0, 1);\n" 7531 " EmitVertex();\n" 7532 " gs_fs_result = result;\n" 7533 " gl_Position = vec4(-1, 1, 0, 1);\n" 7534 " EmitVertex();\n" 7535 " gs_fs_result = result;\n" 7536 " gl_Position = vec4(1, -1, 0, 1);\n" 7537 " EmitVertex();\n" 7538 " gs_fs_result = result;\n" 7539 " gl_Position = vec4(1, 1, 0, 1);\n" 7540 " EmitVertex();\n" 7541 "}\n" 7542 "\n"; 7543 7544 static const GLchar* tess_ctrl_shader_template = 7545 "VERSION\n" 7546 "\n" 7547 "layout(vertices = 1) out;\n" 7548 "\n" 7549 "in vec4 vs_tcs_result[];\n" 7550 "out vec4 tcs_tes_result[];\n" 7551 "\n" 7552 "uniform vec4 VARIABLE_NAME;\n" 7553 "\n" 7554 "FUNCTION_DECLARATION\n" 7555 "\n" 7556 "void main()\n" 7557 "{\n" 7558 " vec4 result = vec4(0, 1, 0, 1);\n" 7559 "\n" 7560 "VERIFICATION" 7561 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 7562 " {\n" 7563 " result = vec4(1, 0, 0, 1);\n" 7564 " }\n" 7565 "\n" 7566 " tcs_tes_result[gl_InvocationID] = result;\n" 7567 "\n" 7568 " gl_TessLevelOuter[0] = 1.0;\n" 7569 " gl_TessLevelOuter[1] = 1.0;\n" 7570 " gl_TessLevelOuter[2] = 1.0;\n" 7571 " gl_TessLevelOuter[3] = 1.0;\n" 7572 " gl_TessLevelInner[0] = 1.0;\n" 7573 " gl_TessLevelInner[1] = 1.0;\n" 7574 "}\n" 7575 "\n"; 7576 7577 static const GLchar* tess_eval_shader_template = "VERSION\n" 7578 "\n" 7579 "layout(isolines, point_mode) in;\n" 7580 "\n" 7581 "in vec4 tcs_tes_result[];\n" 7582 "out vec4 tes_gs_result;\n" 7583 "\n" 7584 "uniform vec4 VARIABLE_NAME;\n" 7585 "\n" 7586 "FUNCTION_DECLARATION\n" 7587 "\n" 7588 "void main()\n" 7589 "{\n" 7590 " vec4 result = vec4(0, 1, 0, 1);\n" 7591 "\n" 7592 "VERIFICATION" 7593 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 7594 " {\n" 7595 " result = vec4(1, 0, 0, 1);\n" 7596 " }\n" 7597 "\n" 7598 " tes_gs_result = result;\n" 7599 "}\n" 7600 "\n"; 7601 7602 static const GLchar* vertex_shader_template = "VERSION\n" 7603 "\n" 7604 "out vec4 vs_tcs_result;\n" 7605 "\n" 7606 "uniform vec4 VARIABLE_NAME;\n" 7607 "\n" 7608 "FUNCTION_DECLARATION\n" 7609 "\n" 7610 "void main()\n" 7611 "{\n" 7612 " vec4 result = vec4(0, 1, 0, 1);\n" 7613 "\n" 7614 "VERIFICATION" 7615 "\n" 7616 " vs_tcs_result = result;\n" 7617 "}\n" 7618 "\n"; 7619 7620 const GLchar* shader_template = 0; 7621 7622 switch (in_stage) 7623 { 7624 case Utils::COMPUTE_SHADER: 7625 return; 7626 break; 7627 case Utils::FRAGMENT_SHADER: 7628 shader_template = fragment_shader_template; 7629 break; 7630 case Utils::GEOMETRY_SHADER: 7631 shader_template = geometry_shader_template; 7632 break; 7633 case Utils::TESS_CTRL_SHADER: 7634 shader_template = tess_ctrl_shader_template; 7635 break; 7636 case Utils::TESS_EVAL_SHADER: 7637 shader_template = tess_eval_shader_template; 7638 break; 7639 case Utils::VERTEX_SHADER: 7640 shader_template = vertex_shader_template; 7641 break; 7642 default: 7643 TCU_FAIL("Invalid enum"); 7644 break; 7645 } 7646 7647 const std::string& uni_reference = Utils::getVariableName(in_stage, Utils::UNIFORM, "test"); 7648 const std::string& qualifier_list = Utils::getQualifiersListString(getCurrentTestCase()); 7649 7650 out_source.m_parts[0].m_code = shader_template; 7651 7652 size_t position = 0; 7653 7654 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 7655 out_source.m_parts[0].m_code); 7656 7657 Utils::replaceToken("FUNCTION_DECLARATION", position, function_declaration, out_source.m_parts[0].m_code); 7658 7659 position -= strlen(function_declaration); 7660 7661 Utils::replaceToken("QUALIFIERS_LIST", position, qualifier_list.c_str(), out_source.m_parts[0].m_code); 7662 7663 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 7664 7665 Utils::replaceAllTokens("VARIABLE_NAME", uni_reference.c_str(), out_source.m_parts[0].m_code); 7666 } 7667 7668 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 7669 * 7670 * @param program Current program 7671 **/ 7672 void QualifierOrderFunctionOutputTest::prepareUniforms(Utils::program& program) 7673 { 7674 static const GLfloat float_data[4] = { 1.0f, 1.0f, 0.0f, 0.0f }; 7675 7676 program.uniform("uni_fs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7677 program.uniform("uni_gs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7678 program.uniform("uni_tcs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7679 program.uniform("uni_tes_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7680 program.uniform("uni_vs_test", Utils::FLOAT, 1 /* n_cols */, 4 /* n_rows */, float_data); 7681 } 7682 7683 /** Prepare test cases 7684 * 7685 * @return false if ARB_explicit_uniform_location is not supported, true otherwise 7686 **/ 7687 bool QualifierOrderFunctionOutputTest::testInit() 7688 { 7689 m_test_cases.resize(6); 7690 7691 m_test_cases[0].push_back(Utils::QUAL_HIGHP); 7692 m_test_cases[0].push_back(Utils::QUAL_PRECISE); 7693 m_test_cases[0].push_back(Utils::QUAL_OUT); 7694 7695 m_test_cases[1].push_back(Utils::QUAL_OUT); 7696 m_test_cases[1].push_back(Utils::QUAL_PRECISE); 7697 m_test_cases[1].push_back(Utils::QUAL_HIGHP); 7698 7699 m_test_cases[2].push_back(Utils::QUAL_PRECISE); 7700 m_test_cases[2].push_back(Utils::QUAL_MEDIUMP); 7701 m_test_cases[2].push_back(Utils::QUAL_OUT); 7702 7703 m_test_cases[3].push_back(Utils::QUAL_OUT); 7704 m_test_cases[3].push_back(Utils::QUAL_PRECISE); 7705 m_test_cases[3].push_back(Utils::QUAL_MEDIUMP); 7706 7707 m_test_cases[4].push_back(Utils::QUAL_LOWP); 7708 m_test_cases[4].push_back(Utils::QUAL_OUT); 7709 m_test_cases[4].push_back(Utils::QUAL_PRECISE); 7710 7711 m_test_cases[5].push_back(Utils::QUAL_OUT); 7712 m_test_cases[5].push_back(Utils::QUAL_PRECISE); 7713 m_test_cases[5].push_back(Utils::QUAL_LOWP); 7714 7715 return true; 7716 } 7717 7718 /** Returns reference to current test case 7719 * 7720 * @return Reference to testCase 7721 **/ 7722 const Utils::qualifierSet& QualifierOrderFunctionOutputTest::getCurrentTestCase() 7723 { 7724 if ((glw::GLuint)-1 == m_current_test_case_index) 7725 { 7726 return m_test_cases[0]; 7727 } 7728 else 7729 { 7730 return m_test_cases[m_current_test_case_index]; 7731 } 7732 } 7733 7734 /** Constructor 7735 * 7736 * @param context Test context 7737 **/ 7738 QualifierOverrideLayoutTest::QualifierOverrideLayoutTest(deqp::Context& context) 7739 : GLSLTestBase(context, "qualifier_override_layout", "Verifies overriding layout qualifiers") 7740 { 7741 /* Nothing to be done here */ 7742 } 7743 7744 /** Prepare source for given shader stage 7745 * 7746 * @param in_stage Shader stage, compute shader will use 430 7747 * @param in_use_version_400 Select if 400 or 420 should be used 7748 * @param out_source Prepared shader source instance 7749 **/ 7750 void QualifierOverrideLayoutTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 7751 Utils::shaderSource& out_source) 7752 { 7753 static const GLchar* fragment_shader_template = "VERSION\n" 7754 "\n" 7755 "in layout(location = 3) layout(location = 2) vec4 gs_fs_result;\n" 7756 "out vec4 fs_out_result;\n" 7757 "\n" 7758 "void main()\n" 7759 "{\n" 7760 " vec4 result = vec4(0, 1, 0, 1);\n" 7761 "\n" 7762 " if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 7763 " {\n" 7764 " result = vec4(1, 0, 0, 1);\n" 7765 " }\n" 7766 "\n" 7767 " fs_out_result = result;\n" 7768 "}\n" 7769 "\n"; 7770 7771 static const GLchar* geometry_shader_template = 7772 "VERSION\n" 7773 "\n" 7774 "layout(points) in;\n" 7775 "layout(triangle_strip, max_vertices = 2) layout(max_vertices = 4) out;\n" 7776 "\n" 7777 "in layout(location = 3) layout(location = 2) vec4 tes_gs_result[];\n" 7778 "out layout(location = 3) layout(location = 2) vec4 gs_fs_result;\n" 7779 "\n" 7780 "void main()\n" 7781 "{\n" 7782 " vec4 result = vec4(0, 1, 0, 1);\n" 7783 "\n" 7784 " if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 7785 " {\n" 7786 " result = vec4(1, 0, 0, 1);\n" 7787 " }\n" 7788 "\n" 7789 " gs_fs_result = result;\n" 7790 " gl_Position = vec4(-1, -1, 0, 1);\n" 7791 " EmitVertex();\n" 7792 " gs_fs_result = result;\n" 7793 " gl_Position = vec4(-1, 1, 0, 1);\n" 7794 " EmitVertex();\n" 7795 " gs_fs_result = result;\n" 7796 " gl_Position = vec4(1, -1, 0, 1);\n" 7797 " EmitVertex();\n" 7798 " gs_fs_result = result;\n" 7799 " gl_Position = vec4(1, 1, 0, 1);\n" 7800 " EmitVertex();\n" 7801 "}\n" 7802 "\n"; 7803 7804 static const GLchar* tess_ctrl_shader_template = 7805 "VERSION\n" 7806 "\n" 7807 "layout(vertices = 4) layout(vertices = 1) out;\n" 7808 "\n" 7809 "in layout(location = 3) layout(location = 2) vec4 vs_tcs_result[];\n" 7810 "out layout(location = 3) layout(location = 2) vec4 tcs_tes_result[];\n" 7811 "\n" 7812 "void main()\n" 7813 "{\n" 7814 " vec4 result = vec4(0, 1, 0, 1);\n" 7815 "\n" 7816 " if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 7817 " {\n" 7818 " result = vec4(1, 0, 0, 1);\n" 7819 " }\n" 7820 "\n" 7821 " tcs_tes_result[gl_InvocationID] = result;\n" 7822 "\n" 7823 " gl_TessLevelOuter[0] = 1.0;\n" 7824 " gl_TessLevelOuter[1] = 1.0;\n" 7825 " gl_TessLevelOuter[2] = 1.0;\n" 7826 " gl_TessLevelOuter[3] = 1.0;\n" 7827 " gl_TessLevelInner[0] = 1.0;\n" 7828 " gl_TessLevelInner[1] = 1.0;\n" 7829 "}\n" 7830 "\n"; 7831 7832 static const GLchar* tess_eval_shader_template = 7833 "VERSION\n" 7834 "\n" 7835 "layout(isolines, point_mode) in;\n" 7836 "\n" 7837 "in layout(location = 3) layout(location = 2) vec4 tcs_tes_result[];\n" 7838 "out layout(location = 3) layout(location = 2) vec4 tes_gs_result;\n" 7839 "\n" 7840 "void main()\n" 7841 "{\n" 7842 " vec4 result = vec4(0, 1, 0, 1);\n" 7843 "\n" 7844 " if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 7845 " {\n" 7846 " result = vec4(1, 0, 0, 1);\n" 7847 " }\n" 7848 "\n" 7849 " tes_gs_result = result;\n" 7850 "}\n" 7851 "\n"; 7852 7853 static const GLchar* vertex_shader_template = "VERSION\n" 7854 "\n" 7855 "in layout(location = 3) layout(location = 2) vec4 in_vs_test;\n" 7856 "out layout(location = 3) layout(location = 2) vec4 vs_tcs_result;\n" 7857 "\n" 7858 "void main()\n" 7859 "{\n" 7860 " vec4 result = in_vs_test;\n" 7861 "\n" 7862 " vs_tcs_result = result;\n" 7863 "}\n" 7864 "\n"; 7865 7866 const GLchar* shader_template = 0; 7867 7868 switch (in_stage) 7869 { 7870 case Utils::COMPUTE_SHADER: 7871 return; 7872 break; 7873 case Utils::FRAGMENT_SHADER: 7874 shader_template = fragment_shader_template; 7875 break; 7876 case Utils::GEOMETRY_SHADER: 7877 shader_template = geometry_shader_template; 7878 break; 7879 case Utils::TESS_CTRL_SHADER: 7880 shader_template = tess_ctrl_shader_template; 7881 break; 7882 case Utils::TESS_EVAL_SHADER: 7883 shader_template = tess_eval_shader_template; 7884 break; 7885 case Utils::VERTEX_SHADER: 7886 shader_template = vertex_shader_template; 7887 break; 7888 default: 7889 TCU_FAIL("Invalid enum"); 7890 break; 7891 } 7892 7893 out_source.m_parts[0].m_code = shader_template; 7894 7895 size_t position = 0; 7896 7897 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 7898 out_source.m_parts[0].m_code); 7899 } 7900 7901 /**Prepare vertex buffer and vertex array object. 7902 * 7903 * @param program Program instance 7904 * @param buffer Buffer instance 7905 * @param vao VertexArray instance 7906 * 7907 * @return 0 7908 **/ 7909 void QualifierOverrideLayoutTest::prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, 7910 Utils::vertexArray& vao) 7911 { 7912 static const GLint expected_location = 2; 7913 7914 std::string test_name = Utils::getVariableName(Utils::VERTEX_SHADER, Utils::INPUT, "test"); 7915 GLint test_loc = program.getAttribLocation(test_name.c_str()); 7916 7917 if (expected_location != test_loc) 7918 { 7919 TCU_FAIL("Vertex attribute location is invalid"); 7920 } 7921 7922 vao.generate(); 7923 vao.bind(); 7924 7925 buffer.generate(GL_ARRAY_BUFFER); 7926 7927 GLfloat data[] = { 0.0f, 1.0f, 0.0f, 1.0f }; 7928 GLsizeiptr data_size = sizeof(data); 7929 7930 buffer.update(data_size, data, GL_STATIC_DRAW); 7931 7932 /* GL entry points */ 7933 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 7934 7935 /* Set up vao */ 7936 gl.vertexAttribPointer(test_loc, 4 /* size */, GL_FLOAT /* type */, GL_FALSE /* normalized*/, 0 /* stride */, 7937 0 /* offset */); 7938 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer"); 7939 7940 /* Enable attribute */ 7941 gl.enableVertexAttribArray(test_loc); 7942 GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray"); 7943 } 7944 7945 /** Constructor 7946 * 7947 * @param context Test context 7948 **/ 7949 BindingUniformBlocksTest::BindingUniformBlocksTest(deqp::Context& context) 7950 : GLSLTestBase(context, "binding_uniform_blocks", "Test verifies uniform block binding") 7951 , m_goku_buffer(context) 7952 , m_vegeta_buffer(context) 7953 , m_children_buffer(context) 7954 { 7955 /* Nothing to be done here */ 7956 } 7957 7958 /** Prepare source for given shader stage 7959 * 7960 * @param in_stage Shader stage, compute shader will use 430 7961 * @param in_use_version_400 Select if 400 or 420 should be used 7962 * @param out_source Prepared shader source instance 7963 **/ 7964 void BindingUniformBlocksTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 7965 Utils::shaderSource& out_source) 7966 { 7967 static const GLchar* uni_goku = "layout(std140, binding = 0) uniform GOKU {\n" 7968 " vec4 chichi;\n" 7969 "} goku;\n"; 7970 7971 static const GLchar* uni_vegeta = "layout(std140, binding = 1) uniform VEGETA {\n" 7972 " vec3 bulma;\n" 7973 "} vegeta;\n"; 7974 7975 static const GLchar* uni_children = "layout(std140, binding = 3) uniform CHILDREN {\n" 7976 " vec4 gohan;\n" 7977 " vec4 trunks;\n" 7978 "} children;\n\n"; 7979 7980 static const GLchar* verification_snippet = " if ((vec4(1, 0, 0, 0) != goku.chichi) ||\n" 7981 " (vec3(0, 1, 0) != vegeta.bulma) ||\n" 7982 " (vec4(0, 0, 1, 0) != children.gohan) ||\n" 7983 " (vec4(0, 0, 0, 1) != children.trunks) )\n" 7984 " {\n" 7985 " result = vec4(1, 0, 0, 1);\n" 7986 " }\n"; 7987 7988 static const GLchar* compute_shader_template = 7989 "VERSION\n" 7990 "\n" 7991 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 7992 "\n" 7993 "writeonly uniform image2D uni_image;\n" 7994 "\n" 7995 "UNI_GOKU\n" 7996 "UNI_VEGETA\n" 7997 "UNI_CHILDREN\n" 7998 "\n" 7999 "void main()\n" 8000 "{\n" 8001 " vec4 result = vec4(0, 1, 0, 1);\n" 8002 "\n" 8003 "VERIFICATION" 8004 "\n" 8005 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 8006 "}\n" 8007 "\n"; 8008 8009 static const GLchar* fragment_shader_template = "VERSION\n" 8010 "\n" 8011 "in vec4 gs_fs_result;\n" 8012 "out vec4 fs_out_result;\n" 8013 "\n" 8014 "UNI_GOKU\n" 8015 "UNI_VEGETA\n" 8016 "UNI_CHILDREN\n" 8017 "\n" 8018 "void main()\n" 8019 "{\n" 8020 " vec4 result = vec4(0, 1, 0, 1);\n" 8021 "\n" 8022 "VERIFICATION" 8023 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 8024 " {\n" 8025 " result = vec4(1, 0, 0, 1);\n" 8026 " }\n" 8027 "\n" 8028 " fs_out_result = result;\n" 8029 "}\n" 8030 "\n"; 8031 8032 static const GLchar* geometry_shader_template = "VERSION\n" 8033 "\n" 8034 "layout(points) in;\n" 8035 "layout(triangle_strip, max_vertices = 4) out;\n" 8036 "\n" 8037 "in vec4 tes_gs_result[];\n" 8038 "out vec4 gs_fs_result;\n" 8039 "\n" 8040 "UNI_CHILDREN\n" 8041 "UNI_GOKU\n" 8042 "UNI_VEGETA\n" 8043 "\n" 8044 "void main()\n" 8045 "{\n" 8046 " vec4 result = vec4(0, 1, 0, 1);\n" 8047 "\n" 8048 "VERIFICATION" 8049 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 8050 " {\n" 8051 " result = vec4(1, 0, 0, 1);\n" 8052 " }\n" 8053 "\n" 8054 " gs_fs_result = result;\n" 8055 " gl_Position = vec4(-1, -1, 0, 1);\n" 8056 " EmitVertex();\n" 8057 " gs_fs_result = result;\n" 8058 " gl_Position = vec4(-1, 1, 0, 1);\n" 8059 " EmitVertex();\n" 8060 " gs_fs_result = result;\n" 8061 " gl_Position = vec4(1, -1, 0, 1);\n" 8062 " EmitVertex();\n" 8063 " gs_fs_result = result;\n" 8064 " gl_Position = vec4(1, 1, 0, 1);\n" 8065 " EmitVertex();\n" 8066 "}\n" 8067 "\n"; 8068 8069 static const GLchar* tess_ctrl_shader_template = 8070 "VERSION\n" 8071 "\n" 8072 "layout(vertices = 1) out;\n" 8073 "\n" 8074 "in vec4 vs_tcs_result[];\n" 8075 "out vec4 tcs_tes_result[];\n" 8076 "\n" 8077 "UNI_VEGETA\n" 8078 "UNI_CHILDREN\n" 8079 "UNI_GOKU\n" 8080 "\n" 8081 "void main()\n" 8082 "{\n" 8083 " vec4 result = vec4(0, 1, 0, 1);\n" 8084 "\n" 8085 "VERIFICATION" 8086 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 8087 " {\n" 8088 " result = vec4(1, 0, 0, 1);\n" 8089 " }\n" 8090 "\n" 8091 " tcs_tes_result[gl_InvocationID] = result;\n" 8092 "\n" 8093 " gl_TessLevelOuter[0] = 1.0;\n" 8094 " gl_TessLevelOuter[1] = 1.0;\n" 8095 " gl_TessLevelOuter[2] = 1.0;\n" 8096 " gl_TessLevelOuter[3] = 1.0;\n" 8097 " gl_TessLevelInner[0] = 1.0;\n" 8098 " gl_TessLevelInner[1] = 1.0;\n" 8099 "}\n" 8100 "\n"; 8101 8102 static const GLchar* tess_eval_shader_template = "VERSION\n" 8103 "\n" 8104 "layout(isolines, point_mode) in;\n" 8105 "\n" 8106 "in vec4 tcs_tes_result[];\n" 8107 "out vec4 tes_gs_result;\n" 8108 "\n" 8109 "UNI_GOKU\n" 8110 "UNI_CHILDREN\n" 8111 "UNI_VEGETA\n" 8112 "\n" 8113 "void main()\n" 8114 "{\n" 8115 " vec4 result = vec4(0, 1, 0, 1);\n" 8116 "\n" 8117 "VERIFICATION" 8118 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 8119 " {\n" 8120 " result = vec4(1, 0, 0, 1);\n" 8121 " }\n" 8122 "\n" 8123 " tes_gs_result = result;\n" 8124 "}\n" 8125 "\n"; 8126 8127 static const GLchar* vertex_shader_template = "VERSION\n" 8128 "\n" 8129 "out vec4 vs_tcs_result;\n" 8130 "\n" 8131 "UNI_CHILDREN\n" 8132 "UNI_VEGETA\n" 8133 "UNI_GOKU\n" 8134 "\n" 8135 "void main()\n" 8136 "{\n" 8137 " vec4 result = vec4(0, 1, 0, 1);\n" 8138 "\n" 8139 "VERIFICATION" 8140 "\n" 8141 " vs_tcs_result = result;\n" 8142 "}\n" 8143 "\n"; 8144 8145 const GLchar* shader_template = 0; 8146 8147 switch (in_stage) 8148 { 8149 case Utils::COMPUTE_SHADER: 8150 shader_template = compute_shader_template; 8151 break; 8152 case Utils::FRAGMENT_SHADER: 8153 shader_template = fragment_shader_template; 8154 break; 8155 case Utils::GEOMETRY_SHADER: 8156 shader_template = geometry_shader_template; 8157 break; 8158 case Utils::TESS_CTRL_SHADER: 8159 shader_template = tess_ctrl_shader_template; 8160 break; 8161 case Utils::TESS_EVAL_SHADER: 8162 shader_template = tess_eval_shader_template; 8163 break; 8164 case Utils::VERTEX_SHADER: 8165 shader_template = vertex_shader_template; 8166 break; 8167 default: 8168 TCU_FAIL("Invalid enum"); 8169 break; 8170 } 8171 8172 out_source.m_parts[0].m_code = shader_template; 8173 8174 size_t position = 0; 8175 8176 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 8177 out_source.m_parts[0].m_code); 8178 8179 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 8180 8181 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 8182 8183 Utils::replaceAllTokens("UNI_VEGETA", uni_vegeta, out_source.m_parts[0].m_code); 8184 8185 Utils::replaceAllTokens("UNI_CHILDREN", uni_children, out_source.m_parts[0].m_code); 8186 } 8187 8188 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 8189 * 8190 * @param program Current program 8191 **/ 8192 void BindingUniformBlocksTest::prepareUniforms(Utils::program& program) 8193 { 8194 (void)program; 8195 static const GLfloat goku_data[4] = { 1.0f, 0.0f, 0.0f, 0.0f }; 8196 static const GLfloat vegeta_data[3] = { 0.0f, 1.0f, 0.0f }; 8197 static const GLfloat children_data[8] = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; 8198 8199 m_goku_buffer.generate(GL_UNIFORM_BUFFER); 8200 m_vegeta_buffer.generate(GL_UNIFORM_BUFFER); 8201 m_children_buffer.generate(GL_UNIFORM_BUFFER); 8202 8203 m_goku_buffer.update(sizeof(goku_data), (GLvoid*)goku_data, GL_STATIC_DRAW); 8204 m_vegeta_buffer.update(sizeof(vegeta_data), (GLvoid*)vegeta_data, GL_STATIC_DRAW); 8205 m_children_buffer.update(sizeof(children_data), (GLvoid*)children_data, GL_STATIC_DRAW); 8206 8207 m_goku_buffer.bindRange(0 /* index */, 0 /* offset */, sizeof(goku_data)); 8208 m_vegeta_buffer.bindRange(1 /* index */, 0 /* offset */, sizeof(vegeta_data)); 8209 m_children_buffer.bindRange(3 /* index */, 0 /* offset */, sizeof(children_data)); 8210 } 8211 8212 /** Overwrite of releaseResource method, release extra uniform buffer 8213 * 8214 * @param ignored 8215 **/ 8216 void BindingUniformBlocksTest::releaseResource() 8217 { 8218 m_goku_buffer.release(); 8219 m_vegeta_buffer.release(); 8220 m_children_buffer.release(); 8221 } 8222 8223 /** Constructor 8224 * 8225 * @param context Test context 8226 **/ 8227 BindingUniformSingleBlockTest::BindingUniformSingleBlockTest(deqp::Context& context) 8228 : GLSLTestBase(context, "binding_uniform_single_block", "Test verifies uniform block binding") 8229 , m_goku_buffer(context) 8230 { 8231 /* Nothing to be done here */ 8232 } 8233 8234 /** Set up next test case 8235 * 8236 * @param test_case_index Index of next test case 8237 * 8238 * @return false if there is no more test cases, true otherwise 8239 **/ 8240 bool BindingUniformSingleBlockTest::prepareNextTestCase(glw::GLuint test_case_index) 8241 { 8242 switch (test_case_index) 8243 { 8244 case (glw::GLuint)-1: 8245 case 0: 8246 m_test_stage = Utils::VERTEX_SHADER; 8247 break; 8248 case 1: 8249 m_test_stage = Utils::TESS_CTRL_SHADER; 8250 break; 8251 case 2: 8252 m_test_stage = Utils::TESS_EVAL_SHADER; 8253 break; 8254 case 3: 8255 m_test_stage = Utils::GEOMETRY_SHADER; 8256 break; 8257 case 4: 8258 m_test_stage = Utils::FRAGMENT_SHADER; 8259 break; 8260 default: 8261 return false; 8262 break; 8263 } 8264 8265 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Tested stage: " 8266 << Utils::getShaderStageName((Utils::SHADER_STAGES)m_test_stage) 8267 << tcu::TestLog::EndMessage; 8268 8269 return true; 8270 } 8271 8272 /** Prepare source for given shader stage 8273 * 8274 * @param in_stage Shader stage, compute shader will use 430 8275 * @param in_use_version_400 Select if 400 or 420 should be used 8276 * @param out_source Prepared shader source instance 8277 **/ 8278 void BindingUniformSingleBlockTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 8279 Utils::shaderSource& out_source) 8280 { 8281 static const GLchar* uni_goku_with_binding = "layout(std140, binding = 0) uniform GOKU {\n" 8282 " vec4 gohan;\n" 8283 " vec4 goten;\n" 8284 "} goku;\n"; 8285 8286 static const GLchar* uni_goku_no_binding = "layout(std140) uniform GOKU {\n" 8287 " vec4 gohan;\n" 8288 " vec4 goten;\n" 8289 "} goku;\n"; 8290 8291 static const GLchar* verification_snippet = " if ((vec4(1, 0, 0, 0) != goku.gohan) ||\n" 8292 " (vec4(0, 1, 0, 0) != goku.goten) )\n" 8293 " {\n" 8294 " result = vec4(1, 0, 0, 1);\n" 8295 " }\n"; 8296 8297 static const GLchar* compute_shader_template = 8298 "VERSION\n" 8299 "\n" 8300 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 8301 "\n" 8302 "writeonly uniform image2D uni_image;\n" 8303 "\n" 8304 "UNI_GOKU\n" 8305 "\n" 8306 "void main()\n" 8307 "{\n" 8308 " vec4 result = vec4(0, 1, 0, 1);\n" 8309 "\n" 8310 "VERIFICATION" 8311 "\n" 8312 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 8313 "}\n" 8314 "\n"; 8315 8316 static const GLchar* fragment_shader_template = "VERSION\n" 8317 "\n" 8318 "in vec4 gs_fs_result;\n" 8319 "out vec4 fs_out_result;\n" 8320 "\n" 8321 "UNI_GOKU\n" 8322 "\n" 8323 "void main()\n" 8324 "{\n" 8325 " vec4 result = vec4(0, 1, 0, 1);\n" 8326 "\n" 8327 "VERIFICATION" 8328 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 8329 " {\n" 8330 " result = vec4(1, 0, 0, 1);\n" 8331 " }\n" 8332 "\n" 8333 " fs_out_result = result;\n" 8334 "}\n" 8335 "\n"; 8336 8337 static const GLchar* geometry_shader_template = "VERSION\n" 8338 "\n" 8339 "layout(points) in;\n" 8340 "layout(triangle_strip, max_vertices = 4) out;\n" 8341 "\n" 8342 "in vec4 tes_gs_result[];\n" 8343 "out vec4 gs_fs_result;\n" 8344 "\n" 8345 "UNI_GOKU\n" 8346 "\n" 8347 "void main()\n" 8348 "{\n" 8349 " vec4 result = vec4(0, 1, 0, 1);\n" 8350 "\n" 8351 "VERIFICATION" 8352 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 8353 " {\n" 8354 " result = vec4(1, 0, 0, 1);\n" 8355 " }\n" 8356 "\n" 8357 " gs_fs_result = result;\n" 8358 " gl_Position = vec4(-1, -1, 0, 1);\n" 8359 " EmitVertex();\n" 8360 " gs_fs_result = result;\n" 8361 " gl_Position = vec4(-1, 1, 0, 1);\n" 8362 " EmitVertex();\n" 8363 " gs_fs_result = result;\n" 8364 " gl_Position = vec4(1, -1, 0, 1);\n" 8365 " EmitVertex();\n" 8366 " gs_fs_result = result;\n" 8367 " gl_Position = vec4(1, 1, 0, 1);\n" 8368 " EmitVertex();\n" 8369 "}\n" 8370 "\n"; 8371 8372 static const GLchar* tess_ctrl_shader_template = 8373 "VERSION\n" 8374 "\n" 8375 "layout(vertices = 1) out;\n" 8376 "\n" 8377 "in vec4 vs_tcs_result[];\n" 8378 "out vec4 tcs_tes_result[];\n" 8379 "\n" 8380 "UNI_GOKU\n" 8381 "\n" 8382 "void main()\n" 8383 "{\n" 8384 " vec4 result = vec4(0, 1, 0, 1);\n" 8385 "\n" 8386 "VERIFICATION" 8387 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 8388 " {\n" 8389 " result = vec4(1, 0, 0, 1);\n" 8390 " }\n" 8391 "\n" 8392 " tcs_tes_result[gl_InvocationID] = result;\n" 8393 "\n" 8394 " gl_TessLevelOuter[0] = 1.0;\n" 8395 " gl_TessLevelOuter[1] = 1.0;\n" 8396 " gl_TessLevelOuter[2] = 1.0;\n" 8397 " gl_TessLevelOuter[3] = 1.0;\n" 8398 " gl_TessLevelInner[0] = 1.0;\n" 8399 " gl_TessLevelInner[1] = 1.0;\n" 8400 "}\n" 8401 "\n"; 8402 8403 static const GLchar* tess_eval_shader_template = "VERSION\n" 8404 "\n" 8405 "layout(isolines, point_mode) in;\n" 8406 "\n" 8407 "in vec4 tcs_tes_result[];\n" 8408 "out vec4 tes_gs_result;\n" 8409 "\n" 8410 "UNI_GOKU\n" 8411 "\n" 8412 "void main()\n" 8413 "{\n" 8414 " vec4 result = vec4(0, 1, 0, 1);\n" 8415 "\n" 8416 "VERIFICATION" 8417 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 8418 " {\n" 8419 " result = vec4(1, 0, 0, 1);\n" 8420 " }\n" 8421 "\n" 8422 " tes_gs_result = result;\n" 8423 "}\n" 8424 "\n"; 8425 8426 static const GLchar* vertex_shader_template = "VERSION\n" 8427 "\n" 8428 "out vec4 vs_tcs_result;\n" 8429 "\n" 8430 "UNI_GOKU\n" 8431 "\n" 8432 "void main()\n" 8433 "{\n" 8434 " vec4 result = vec4(0, 1, 0, 1);\n" 8435 "\n" 8436 "VERIFICATION" 8437 "\n" 8438 " vs_tcs_result = result;\n" 8439 "}\n" 8440 "\n"; 8441 8442 const GLchar* shader_template = 0; 8443 const GLchar* uniform_definition = uni_goku_no_binding; 8444 8445 switch (in_stage) 8446 { 8447 case Utils::COMPUTE_SHADER: 8448 shader_template = compute_shader_template; 8449 uniform_definition = uni_goku_with_binding; 8450 break; 8451 case Utils::FRAGMENT_SHADER: 8452 shader_template = fragment_shader_template; 8453 break; 8454 case Utils::GEOMETRY_SHADER: 8455 shader_template = geometry_shader_template; 8456 break; 8457 case Utils::TESS_CTRL_SHADER: 8458 shader_template = tess_ctrl_shader_template; 8459 break; 8460 case Utils::TESS_EVAL_SHADER: 8461 shader_template = tess_eval_shader_template; 8462 break; 8463 case Utils::VERTEX_SHADER: 8464 shader_template = vertex_shader_template; 8465 break; 8466 default: 8467 TCU_FAIL("Invalid enum"); 8468 break; 8469 } 8470 8471 if (in_stage == m_test_stage) 8472 { 8473 uniform_definition = uni_goku_with_binding; 8474 } 8475 8476 out_source.m_parts[0].m_code = shader_template; 8477 8478 size_t position = 0; 8479 8480 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 8481 out_source.m_parts[0].m_code); 8482 8483 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 8484 8485 Utils::replaceAllTokens("UNI_GOKU", uniform_definition, out_source.m_parts[0].m_code); 8486 } 8487 8488 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 8489 * 8490 * @param program Current program 8491 **/ 8492 void BindingUniformSingleBlockTest::prepareUniforms(Utils::program& program) 8493 { 8494 (void)program; 8495 static const GLfloat goku_data[8] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }; 8496 8497 m_goku_buffer.generate(GL_UNIFORM_BUFFER); 8498 8499 m_goku_buffer.update(sizeof(goku_data), (GLvoid*)goku_data, GL_STATIC_DRAW); 8500 8501 m_goku_buffer.bindRange(0 /* index */, 0 /* offset */, sizeof(goku_data)); 8502 } 8503 8504 /** Overwrite of releaseResource method, release extra uniform buffer 8505 * 8506 * @param ignored 8507 **/ 8508 void BindingUniformSingleBlockTest::releaseResource() 8509 { 8510 m_goku_buffer.release(); 8511 } 8512 8513 /** Constructor 8514 * 8515 * @param context Test context 8516 **/ 8517 BindingUniformBlockArrayTest::BindingUniformBlockArrayTest(deqp::Context& context) 8518 : GLSLTestBase(context, "binding_uniform_block_array", "Test verifies binding of uniform block arrays") 8519 , m_goku_00_buffer(context) 8520 , m_goku_01_buffer(context) 8521 , m_goku_02_buffer(context) 8522 , m_goku_03_buffer(context) 8523 , m_goku_04_buffer(context) 8524 , m_goku_05_buffer(context) 8525 , m_goku_06_buffer(context) 8526 , m_goku_07_buffer(context) 8527 , m_goku_08_buffer(context) 8528 , m_goku_09_buffer(context) 8529 , m_goku_10_buffer(context) 8530 , m_goku_11_buffer(context) 8531 , m_goku_12_buffer(context) 8532 , m_goku_13_buffer(context) 8533 { 8534 /* Nothing to be done here */ 8535 } 8536 8537 /** Prepare source for given shader stage 8538 * 8539 * @param in_stage Shader stage, compute shader will use 430 8540 * @param in_use_version_400 Select if 400 or 420 should be used 8541 * @param out_source Prepared shader source instance 8542 **/ 8543 void BindingUniformBlockArrayTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 8544 Utils::shaderSource& out_source) 8545 { 8546 static const GLchar* uni_goku = "layout(std140, binding = 2) uniform GOKU {\n" 8547 " vec4 gohan;\n" 8548 " vec4 goten;\n" 8549 "} goku[14];\n"; 8550 8551 static const GLchar* verification_snippet = " if ((vec4(0, 0, 0, 0) != goku[0].gohan) ||\n" 8552 " (vec4(0, 0, 0, 1) != goku[0].goten) ||\n" 8553 " (vec4(0, 0, 1, 0) != goku[1].gohan) ||\n" 8554 " (vec4(0, 0, 1, 1) != goku[1].goten) ||\n" 8555 " (vec4(0, 1, 0, 0) != goku[2].gohan) ||\n" 8556 " (vec4(0, 1, 0, 1) != goku[2].goten) ||\n" 8557 " (vec4(0, 1, 1, 0) != goku[3].gohan) ||\n" 8558 " (vec4(0, 1, 1, 1) != goku[3].goten) ||\n" 8559 " (vec4(1, 0, 0, 0) != goku[4].gohan) ||\n" 8560 " (vec4(1, 0, 0, 1) != goku[4].goten) ||\n" 8561 " (vec4(1, 0, 1, 0) != goku[5].gohan) ||\n" 8562 " (vec4(1, 0, 1, 1) != goku[5].goten) ||\n" 8563 " (vec4(1, 1, 0, 0) != goku[6].gohan) ||\n" 8564 " (vec4(1, 1, 0, 1) != goku[6].goten) ||\n" 8565 " (vec4(1, 1, 1, 0) != goku[7].gohan) ||\n" 8566 " (vec4(1, 1, 1, 1) != goku[7].goten) ||\n" 8567 " (vec4(0, 0, 0, 0) != goku[8].gohan) ||\n" 8568 " (vec4(0, 0, 0, 1) != goku[8].goten) ||\n" 8569 " (vec4(0, 0, 1, 0) != goku[9].gohan) ||\n" 8570 " (vec4(0, 0, 1, 1) != goku[9].goten) ||\n" 8571 " (vec4(0, 1, 0, 0) != goku[10].gohan) ||\n" 8572 " (vec4(0, 1, 0, 1) != goku[10].goten) ||\n" 8573 " (vec4(0, 1, 1, 0) != goku[11].gohan) ||\n" 8574 " (vec4(0, 1, 1, 1) != goku[11].goten) ||\n" 8575 " (vec4(1, 0, 0, 0) != goku[12].gohan) ||\n" 8576 " (vec4(1, 0, 0, 1) != goku[12].goten) ||\n" 8577 " (vec4(1, 0, 1, 0) != goku[13].gohan) ||\n" 8578 " (vec4(1, 0, 1, 1) != goku[13].goten) )\n" 8579 " {\n" 8580 " result = vec4(1, 0, 0, 1);\n" 8581 " }\n"; 8582 8583 static const GLchar* compute_shader_template = 8584 "VERSION\n" 8585 "\n" 8586 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 8587 "\n" 8588 "writeonly uniform image2D uni_image;\n" 8589 "\n" 8590 "UNI_GOKU\n" 8591 "\n" 8592 "void main()\n" 8593 "{\n" 8594 " vec4 result = vec4(0, 1, 0, 1);\n" 8595 "\n" 8596 "VERIFICATION" 8597 "\n" 8598 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 8599 "}\n" 8600 "\n"; 8601 8602 static const GLchar* fragment_shader_template = "VERSION\n" 8603 "\n" 8604 "in vec4 gs_fs_result;\n" 8605 "out vec4 fs_out_result;\n" 8606 "\n" 8607 "UNI_GOKU\n" 8608 "\n" 8609 "void main()\n" 8610 "{\n" 8611 " vec4 result = vec4(0, 1, 0, 1);\n" 8612 "\n" 8613 "VERIFICATION" 8614 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 8615 " {\n" 8616 " result = vec4(1, 0, 0, 1);\n" 8617 " }\n" 8618 "\n" 8619 " fs_out_result = result;\n" 8620 "}\n" 8621 "\n"; 8622 8623 static const GLchar* geometry_shader_template = "VERSION\n" 8624 "\n" 8625 "layout(points) in;\n" 8626 "layout(triangle_strip, max_vertices = 4) out;\n" 8627 "\n" 8628 "in vec4 tes_gs_result[];\n" 8629 "out vec4 gs_fs_result;\n" 8630 "\n" 8631 "UNI_GOKU\n" 8632 "\n" 8633 "void main()\n" 8634 "{\n" 8635 " vec4 result = vec4(0, 1, 0, 1);\n" 8636 "\n" 8637 "VERIFICATION" 8638 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 8639 " {\n" 8640 " result = vec4(1, 0, 0, 1);\n" 8641 " }\n" 8642 "\n" 8643 " gs_fs_result = result;\n" 8644 " gl_Position = vec4(-1, -1, 0, 1);\n" 8645 " EmitVertex();\n" 8646 " gs_fs_result = result;\n" 8647 " gl_Position = vec4(-1, 1, 0, 1);\n" 8648 " EmitVertex();\n" 8649 " gs_fs_result = result;\n" 8650 " gl_Position = vec4(1, -1, 0, 1);\n" 8651 " EmitVertex();\n" 8652 " gs_fs_result = result;\n" 8653 " gl_Position = vec4(1, 1, 0, 1);\n" 8654 " EmitVertex();\n" 8655 "}\n" 8656 "\n"; 8657 8658 static const GLchar* tess_ctrl_shader_template = 8659 "VERSION\n" 8660 "\n" 8661 "layout(vertices = 1) out;\n" 8662 "\n" 8663 "in vec4 vs_tcs_result[];\n" 8664 "out vec4 tcs_tes_result[];\n" 8665 "\n" 8666 "UNI_GOKU\n" 8667 "\n" 8668 "void main()\n" 8669 "{\n" 8670 " vec4 result = vec4(0, 1, 0, 1);\n" 8671 "\n" 8672 "VERIFICATION" 8673 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 8674 " {\n" 8675 " result = vec4(1, 0, 0, 1);\n" 8676 " }\n" 8677 "\n" 8678 " tcs_tes_result[gl_InvocationID] = result;\n" 8679 "\n" 8680 " gl_TessLevelOuter[0] = 1.0;\n" 8681 " gl_TessLevelOuter[1] = 1.0;\n" 8682 " gl_TessLevelOuter[2] = 1.0;\n" 8683 " gl_TessLevelOuter[3] = 1.0;\n" 8684 " gl_TessLevelInner[0] = 1.0;\n" 8685 " gl_TessLevelInner[1] = 1.0;\n" 8686 "}\n" 8687 "\n"; 8688 8689 static const GLchar* tess_eval_shader_template = "VERSION\n" 8690 "\n" 8691 "layout(isolines, point_mode) in;\n" 8692 "\n" 8693 "in vec4 tcs_tes_result[];\n" 8694 "out vec4 tes_gs_result;\n" 8695 "\n" 8696 "UNI_GOKU\n" 8697 "\n" 8698 "void main()\n" 8699 "{\n" 8700 " vec4 result = vec4(0, 1, 0, 1);\n" 8701 "\n" 8702 "VERIFICATION" 8703 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 8704 " {\n" 8705 " result = vec4(1, 0, 0, 1);\n" 8706 " }\n" 8707 "\n" 8708 " tes_gs_result = result;\n" 8709 "}\n" 8710 "\n"; 8711 8712 static const GLchar* vertex_shader_template = "VERSION\n" 8713 "\n" 8714 "out vec4 vs_tcs_result;\n" 8715 "\n" 8716 "UNI_GOKU\n" 8717 "\n" 8718 "void main()\n" 8719 "{\n" 8720 " vec4 result = vec4(0, 1, 0, 1);\n" 8721 "\n" 8722 "VERIFICATION" 8723 "\n" 8724 " vs_tcs_result = result;\n" 8725 "}\n" 8726 "\n"; 8727 8728 const GLchar* shader_template = 0; 8729 8730 switch (in_stage) 8731 { 8732 case Utils::COMPUTE_SHADER: 8733 shader_template = compute_shader_template; 8734 break; 8735 case Utils::FRAGMENT_SHADER: 8736 shader_template = fragment_shader_template; 8737 break; 8738 case Utils::GEOMETRY_SHADER: 8739 shader_template = geometry_shader_template; 8740 break; 8741 case Utils::TESS_CTRL_SHADER: 8742 shader_template = tess_ctrl_shader_template; 8743 break; 8744 case Utils::TESS_EVAL_SHADER: 8745 shader_template = tess_eval_shader_template; 8746 break; 8747 case Utils::VERTEX_SHADER: 8748 shader_template = vertex_shader_template; 8749 break; 8750 default: 8751 TCU_FAIL("Invalid enum"); 8752 break; 8753 } 8754 8755 out_source.m_parts[0].m_code = shader_template; 8756 8757 size_t position = 0; 8758 8759 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 8760 out_source.m_parts[0].m_code); 8761 8762 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 8763 8764 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 8765 } 8766 8767 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 8768 * 8769 * @param program Current program 8770 **/ 8771 void BindingUniformBlockArrayTest::prepareUniforms(Utils::program& program) 8772 { 8773 static const GLfloat goku_data[][8] = { 8774 { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f }, 8775 { 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f }, 8776 { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f }, { 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f }, 8777 { 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, 8778 { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f }, 8779 { 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f }, 8780 { 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f }, { 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f } 8781 }; 8782 8783 Utils::buffer* buffers[14] = { &m_goku_00_buffer, &m_goku_01_buffer, &m_goku_02_buffer, &m_goku_03_buffer, 8784 &m_goku_04_buffer, &m_goku_05_buffer, &m_goku_06_buffer, &m_goku_07_buffer, 8785 &m_goku_08_buffer, &m_goku_09_buffer, &m_goku_10_buffer, &m_goku_11_buffer, 8786 &m_goku_12_buffer, &m_goku_13_buffer }; 8787 8788 for (GLuint i = 0; i < 14; ++i) 8789 { 8790 checkBinding(program, i, i + 2); 8791 8792 buffers[i]->generate(GL_UNIFORM_BUFFER); 8793 buffers[i]->update(sizeof(GLfloat) * 8, (GLvoid*)goku_data[i], GL_STATIC_DRAW); 8794 buffers[i]->bindRange(i + 2 /* index */, 0 /* offset */, sizeof(GLfloat) * 8); 8795 } 8796 } 8797 8798 /** Overwrite of releaseResource method, release extra uniform buffer 8799 * 8800 * @param ignored 8801 **/ 8802 void BindingUniformBlockArrayTest::releaseResource() 8803 { 8804 Utils::buffer* buffers[14] = { &m_goku_00_buffer, &m_goku_01_buffer, &m_goku_02_buffer, &m_goku_03_buffer, 8805 &m_goku_04_buffer, &m_goku_05_buffer, &m_goku_06_buffer, &m_goku_07_buffer, 8806 &m_goku_08_buffer, &m_goku_09_buffer, &m_goku_10_buffer, &m_goku_11_buffer, 8807 &m_goku_12_buffer, &m_goku_13_buffer }; 8808 8809 for (GLuint i = 0; i < 14; ++i) 8810 { 8811 buffers[i]->release(); 8812 } 8813 } 8814 8815 /** Verifies that API reports correct uniform binding 8816 * 8817 * @param program Program 8818 * @param index Index of array element 8819 * @param expected_binding Expected binding 8820 **/ 8821 void BindingUniformBlockArrayTest::checkBinding(Utils::program& program, glw::GLuint index, glw::GLint expected_binding) 8822 { 8823 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 8824 8825 GLchar buffer[64]; 8826 sprintf(buffer, "GOKU[%d]", index); 8827 8828 const GLuint uniform_index = gl.getUniformBlockIndex(program.m_program_object_id, buffer); 8829 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformBlockIndex"); 8830 if (GL_INVALID_INDEX == uniform_index) 8831 { 8832 TCU_FAIL("Uniform block is inactive"); 8833 } 8834 8835 GLint binding = -1; 8836 8837 gl.getActiveUniformBlockiv(program.m_program_object_id, uniform_index, GL_UNIFORM_BLOCK_BINDING, &binding); 8838 GLU_EXPECT_NO_ERROR(gl.getError(), "GetActiveUniformBlockiv"); 8839 8840 if (expected_binding != binding) 8841 { 8842 TCU_FAIL("Wrong binding reported by API"); 8843 } 8844 } 8845 8846 /** Constructor 8847 * 8848 * @param context Test context 8849 **/ 8850 BindingUniformDefaultTest::BindingUniformDefaultTest(deqp::Context& context) 8851 : APITestBase(context, "binding_uniform_default", "Test verifies default binding of uniform block") 8852 { 8853 /* Nothing to be done here */ 8854 } 8855 8856 /** Execute API call and verifies results 8857 * 8858 * @return true when results are positive, false otherwise 8859 **/ 8860 bool BindingUniformDefaultTest::checkResults(Utils::program& program) 8861 { 8862 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 8863 8864 const GLuint index = gl.getUniformBlockIndex(program.m_program_object_id, "GOKU"); 8865 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformBlockIndex"); 8866 if (GL_INVALID_INDEX == index) 8867 { 8868 TCU_FAIL("Uniform block is inactive"); 8869 return false; 8870 } 8871 8872 GLint binding = -1; 8873 8874 gl.getActiveUniformBlockiv(program.m_program_object_id, index, GL_UNIFORM_BLOCK_BINDING, &binding); 8875 GLU_EXPECT_NO_ERROR(gl.getError(), "GetActiveUniformBlockiv"); 8876 8877 if (0 != binding) 8878 { 8879 return false; 8880 } 8881 8882 return true; 8883 } 8884 8885 /** Prepare source for given shader stage 8886 * 8887 * @param in_stage Shader stage, compute shader will use 430 8888 * @param in_use_version_400 Select if 400 or 420 should be used 8889 * @param out_source Prepared shader source instance 8890 **/ 8891 void BindingUniformDefaultTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 8892 Utils::shaderSource& out_source) 8893 { 8894 static const GLchar* uni_goku = "layout(std140) uniform GOKU {\n" 8895 " vec4 gohan;\n" 8896 " vec4 goten;\n" 8897 "} goku;\n"; 8898 8899 static const GLchar* verification_snippet = " if ((vec4(0, 0, 0, 0) != goku.gohan) ||\n" 8900 " (vec4(0, 0, 0, 1) != goku.goten) )\n" 8901 " {\n" 8902 " result = vec4(1, 0, 0, 1);\n" 8903 " }\n"; 8904 8905 static const GLchar* compute_shader_template = 8906 "VERSION\n" 8907 "\n" 8908 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 8909 "\n" 8910 "writeonly uniform image2D uni_image;\n" 8911 "\n" 8912 "UNI_GOKU\n" 8913 "\n" 8914 "void main()\n" 8915 "{\n" 8916 " vec4 result = vec4(0, 1, 0, 1);\n" 8917 "\n" 8918 "VERIFICATION" 8919 "\n" 8920 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 8921 "}\n" 8922 "\n"; 8923 8924 static const GLchar* fragment_shader_template = "VERSION\n" 8925 "\n" 8926 "in vec4 gs_fs_result;\n" 8927 "out vec4 fs_out_result;\n" 8928 "\n" 8929 "UNI_GOKU\n" 8930 "\n" 8931 "void main()\n" 8932 "{\n" 8933 " vec4 result = vec4(0, 1, 0, 1);\n" 8934 "\n" 8935 "VERIFICATION" 8936 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 8937 " {\n" 8938 " result = vec4(1, 0, 0, 1);\n" 8939 " }\n" 8940 "\n" 8941 " fs_out_result = result;\n" 8942 "}\n" 8943 "\n"; 8944 8945 static const GLchar* geometry_shader_template = "VERSION\n" 8946 "\n" 8947 "layout(points) in;\n" 8948 "layout(triangle_strip, max_vertices = 4) out;\n" 8949 "\n" 8950 "in vec4 tes_gs_result[];\n" 8951 "out vec4 gs_fs_result;\n" 8952 "\n" 8953 "UNI_GOKU\n" 8954 "\n" 8955 "void main()\n" 8956 "{\n" 8957 " vec4 result = vec4(0, 1, 0, 1);\n" 8958 "\n" 8959 "VERIFICATION" 8960 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 8961 " {\n" 8962 " result = vec4(1, 0, 0, 1);\n" 8963 " }\n" 8964 "\n" 8965 " gs_fs_result = result;\n" 8966 " gl_Position = vec4(-1, -1, 0, 1);\n" 8967 " EmitVertex();\n" 8968 " gs_fs_result = result;\n" 8969 " gl_Position = vec4(-1, 1, 0, 1);\n" 8970 " EmitVertex();\n" 8971 " gs_fs_result = result;\n" 8972 " gl_Position = vec4(1, -1, 0, 1);\n" 8973 " EmitVertex();\n" 8974 " gs_fs_result = result;\n" 8975 " gl_Position = vec4(1, 1, 0, 1);\n" 8976 " EmitVertex();\n" 8977 "}\n" 8978 "\n"; 8979 8980 static const GLchar* tess_ctrl_shader_template = 8981 "VERSION\n" 8982 "\n" 8983 "layout(vertices = 1) out;\n" 8984 "\n" 8985 "in vec4 vs_tcs_result[];\n" 8986 "out vec4 tcs_tes_result[];\n" 8987 "\n" 8988 "UNI_GOKU\n" 8989 "\n" 8990 "void main()\n" 8991 "{\n" 8992 " vec4 result = vec4(0, 1, 0, 1);\n" 8993 "\n" 8994 "VERIFICATION" 8995 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 8996 " {\n" 8997 " result = vec4(1, 0, 0, 1);\n" 8998 " }\n" 8999 "\n" 9000 " tcs_tes_result[gl_InvocationID] = result;\n" 9001 "\n" 9002 " gl_TessLevelOuter[0] = 1.0;\n" 9003 " gl_TessLevelOuter[1] = 1.0;\n" 9004 " gl_TessLevelOuter[2] = 1.0;\n" 9005 " gl_TessLevelOuter[3] = 1.0;\n" 9006 " gl_TessLevelInner[0] = 1.0;\n" 9007 " gl_TessLevelInner[1] = 1.0;\n" 9008 "}\n" 9009 "\n"; 9010 9011 static const GLchar* tess_eval_shader_template = "VERSION\n" 9012 "\n" 9013 "layout(isolines, point_mode) in;\n" 9014 "\n" 9015 "in vec4 tcs_tes_result[];\n" 9016 "out vec4 tes_gs_result;\n" 9017 "\n" 9018 "UNI_GOKU\n" 9019 "\n" 9020 "void main()\n" 9021 "{\n" 9022 " vec4 result = vec4(0, 1, 0, 1);\n" 9023 "\n" 9024 "VERIFICATION" 9025 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 9026 " {\n" 9027 " result = vec4(1, 0, 0, 1);\n" 9028 " }\n" 9029 "\n" 9030 " tes_gs_result = result;\n" 9031 "}\n" 9032 "\n"; 9033 9034 static const GLchar* vertex_shader_template = "VERSION\n" 9035 "\n" 9036 "out vec4 vs_tcs_result;\n" 9037 "\n" 9038 "UNI_GOKU\n" 9039 "\n" 9040 "void main()\n" 9041 "{\n" 9042 " vec4 result = vec4(0, 1, 0, 1);\n" 9043 "\n" 9044 "VERIFICATION" 9045 "\n" 9046 " vs_tcs_result = result;\n" 9047 "}\n" 9048 "\n"; 9049 9050 const GLchar* shader_template = 0; 9051 9052 switch (in_stage) 9053 { 9054 case Utils::COMPUTE_SHADER: 9055 shader_template = compute_shader_template; 9056 break; 9057 case Utils::FRAGMENT_SHADER: 9058 shader_template = fragment_shader_template; 9059 break; 9060 case Utils::GEOMETRY_SHADER: 9061 shader_template = geometry_shader_template; 9062 break; 9063 case Utils::TESS_CTRL_SHADER: 9064 shader_template = tess_ctrl_shader_template; 9065 break; 9066 case Utils::TESS_EVAL_SHADER: 9067 shader_template = tess_eval_shader_template; 9068 break; 9069 case Utils::VERTEX_SHADER: 9070 shader_template = vertex_shader_template; 9071 break; 9072 default: 9073 TCU_FAIL("Invalid enum"); 9074 break; 9075 } 9076 9077 out_source.m_parts[0].m_code = shader_template; 9078 9079 size_t position = 0; 9080 9081 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 9082 out_source.m_parts[0].m_code); 9083 9084 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 9085 9086 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 9087 } 9088 9089 /** Constructor 9090 * 9091 * @param context Test context 9092 **/ 9093 BindingUniformAPIOverirdeTest::BindingUniformAPIOverirdeTest(deqp::Context& context) 9094 : GLSLTestBase(context, "binding_uniform_api_overirde", "Test verifies if binding can be overriden with API") 9095 , m_goku_buffer(context) 9096 { 9097 /* Nothing to be done here */ 9098 } 9099 9100 /** Prepare source for given shader stage 9101 * 9102 * @param in_stage Shader stage, compute shader will use 430 9103 * @param in_use_version_400 Select if 400 or 420 should be used 9104 * @param out_source Prepared shader source instance 9105 **/ 9106 void BindingUniformAPIOverirdeTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 9107 Utils::shaderSource& out_source) 9108 { 9109 static const GLchar* uni_goku = "layout(std140, binding = 2) uniform GOKU {\n" 9110 " vec4 gohan;\n" 9111 " vec4 goten;\n" 9112 "} goku;\n"; 9113 9114 static const GLchar* verification_snippet = " if ((vec4(1, 0, 0, 0) != goku.gohan) ||\n" 9115 " (vec4(0, 1, 0, 0) != goku.goten) )\n" 9116 " {\n" 9117 " result = vec4(1, 0, 0, 1);\n" 9118 " }\n"; 9119 9120 static const GLchar* compute_shader_template = 9121 "VERSION\n" 9122 "\n" 9123 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 9124 "\n" 9125 "writeonly uniform image2D uni_image;\n" 9126 "\n" 9127 "UNI_GOKU\n" 9128 "\n" 9129 "void main()\n" 9130 "{\n" 9131 " vec4 result = vec4(0, 1, 0, 1);\n" 9132 "\n" 9133 "VERIFICATION" 9134 "\n" 9135 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 9136 "}\n" 9137 "\n"; 9138 9139 static const GLchar* fragment_shader_template = "VERSION\n" 9140 "\n" 9141 "in vec4 gs_fs_result;\n" 9142 "out vec4 fs_out_result;\n" 9143 "\n" 9144 "UNI_GOKU\n" 9145 "\n" 9146 "void main()\n" 9147 "{\n" 9148 " vec4 result = vec4(0, 1, 0, 1);\n" 9149 "\n" 9150 "VERIFICATION" 9151 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 9152 " {\n" 9153 " result = vec4(1, 0, 0, 1);\n" 9154 " }\n" 9155 "\n" 9156 " fs_out_result = result;\n" 9157 "}\n" 9158 "\n"; 9159 9160 static const GLchar* geometry_shader_template = "VERSION\n" 9161 "\n" 9162 "layout(points) in;\n" 9163 "layout(triangle_strip, max_vertices = 4) out;\n" 9164 "\n" 9165 "in vec4 tes_gs_result[];\n" 9166 "out vec4 gs_fs_result;\n" 9167 "\n" 9168 "UNI_GOKU\n" 9169 "\n" 9170 "void main()\n" 9171 "{\n" 9172 " vec4 result = vec4(0, 1, 0, 1);\n" 9173 "\n" 9174 "VERIFICATION" 9175 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 9176 " {\n" 9177 " result = vec4(1, 0, 0, 1);\n" 9178 " }\n" 9179 "\n" 9180 " gs_fs_result = result;\n" 9181 " gl_Position = vec4(-1, -1, 0, 1);\n" 9182 " EmitVertex();\n" 9183 " gs_fs_result = result;\n" 9184 " gl_Position = vec4(-1, 1, 0, 1);\n" 9185 " EmitVertex();\n" 9186 " gs_fs_result = result;\n" 9187 " gl_Position = vec4(1, -1, 0, 1);\n" 9188 " EmitVertex();\n" 9189 " gs_fs_result = result;\n" 9190 " gl_Position = vec4(1, 1, 0, 1);\n" 9191 " EmitVertex();\n" 9192 "}\n" 9193 "\n"; 9194 9195 static const GLchar* tess_ctrl_shader_template = 9196 "VERSION\n" 9197 "\n" 9198 "layout(vertices = 1) out;\n" 9199 "\n" 9200 "in vec4 vs_tcs_result[];\n" 9201 "out vec4 tcs_tes_result[];\n" 9202 "\n" 9203 "UNI_GOKU\n" 9204 "\n" 9205 "void main()\n" 9206 "{\n" 9207 " vec4 result = vec4(0, 1, 0, 1);\n" 9208 "\n" 9209 "VERIFICATION" 9210 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 9211 " {\n" 9212 " result = vec4(1, 0, 0, 1);\n" 9213 " }\n" 9214 "\n" 9215 " tcs_tes_result[gl_InvocationID] = result;\n" 9216 "\n" 9217 " gl_TessLevelOuter[0] = 1.0;\n" 9218 " gl_TessLevelOuter[1] = 1.0;\n" 9219 " gl_TessLevelOuter[2] = 1.0;\n" 9220 " gl_TessLevelOuter[3] = 1.0;\n" 9221 " gl_TessLevelInner[0] = 1.0;\n" 9222 " gl_TessLevelInner[1] = 1.0;\n" 9223 "}\n" 9224 "\n"; 9225 9226 static const GLchar* tess_eval_shader_template = "VERSION\n" 9227 "\n" 9228 "layout(isolines, point_mode) in;\n" 9229 "\n" 9230 "in vec4 tcs_tes_result[];\n" 9231 "out vec4 tes_gs_result;\n" 9232 "\n" 9233 "UNI_GOKU\n" 9234 "\n" 9235 "void main()\n" 9236 "{\n" 9237 " vec4 result = vec4(0, 1, 0, 1);\n" 9238 "\n" 9239 "VERIFICATION" 9240 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 9241 " {\n" 9242 " result = vec4(1, 0, 0, 1);\n" 9243 " }\n" 9244 "\n" 9245 " tes_gs_result = result;\n" 9246 "}\n" 9247 "\n"; 9248 9249 static const GLchar* vertex_shader_template = "VERSION\n" 9250 "\n" 9251 "out vec4 vs_tcs_result;\n" 9252 "\n" 9253 "UNI_GOKU\n" 9254 "\n" 9255 "void main()\n" 9256 "{\n" 9257 " vec4 result = vec4(0, 1, 0, 1);\n" 9258 "\n" 9259 "VERIFICATION" 9260 "\n" 9261 " vs_tcs_result = result;\n" 9262 "}\n" 9263 "\n"; 9264 9265 const GLchar* shader_template = 0; 9266 9267 switch (in_stage) 9268 { 9269 case Utils::COMPUTE_SHADER: 9270 shader_template = compute_shader_template; 9271 break; 9272 case Utils::FRAGMENT_SHADER: 9273 shader_template = fragment_shader_template; 9274 break; 9275 case Utils::GEOMETRY_SHADER: 9276 shader_template = geometry_shader_template; 9277 break; 9278 case Utils::TESS_CTRL_SHADER: 9279 shader_template = tess_ctrl_shader_template; 9280 break; 9281 case Utils::TESS_EVAL_SHADER: 9282 shader_template = tess_eval_shader_template; 9283 break; 9284 case Utils::VERTEX_SHADER: 9285 shader_template = vertex_shader_template; 9286 break; 9287 default: 9288 TCU_FAIL("Invalid enum"); 9289 break; 9290 } 9291 9292 out_source.m_parts[0].m_code = shader_template; 9293 9294 size_t position = 0; 9295 9296 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 9297 out_source.m_parts[0].m_code); 9298 9299 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 9300 9301 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 9302 } 9303 9304 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 9305 * 9306 * @param program Current program 9307 **/ 9308 void BindingUniformAPIOverirdeTest::prepareUniforms(Utils::program& program) 9309 { 9310 static const GLfloat goku_data[8] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f }; 9311 9312 static const GLuint new_binding = 11; 9313 9314 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 9315 9316 const GLuint index = gl.getUniformBlockIndex(program.m_program_object_id, "GOKU"); 9317 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformBlockIndex"); 9318 if (GL_INVALID_INDEX == index) 9319 { 9320 TCU_FAIL("Uniform block is inactive"); 9321 return; 9322 } 9323 9324 gl.uniformBlockBinding(program.m_program_object_id, index, new_binding); 9325 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformBlockBinding"); 9326 9327 GLint binding = -1; 9328 9329 gl.getActiveUniformBlockiv(program.m_program_object_id, index, GL_UNIFORM_BLOCK_BINDING, &binding); 9330 GLU_EXPECT_NO_ERROR(gl.getError(), "GetActiveUniformBlockiv"); 9331 9332 if (new_binding != binding) 9333 { 9334 TCU_FAIL("GetActiveUniformBlockiv returned wrong binding"); 9335 return; 9336 } 9337 9338 m_goku_buffer.generate(GL_UNIFORM_BUFFER); 9339 m_goku_buffer.update(sizeof(GLfloat) * 8, (GLvoid*)goku_data, GL_STATIC_DRAW); 9340 m_goku_buffer.bindRange(new_binding /* index */, 0 /* offset */, sizeof(GLfloat) * 8); 9341 } 9342 9343 /** Overwrite of releaseResource method, release extra uniform buffer 9344 * 9345 * @param ignored 9346 **/ 9347 void BindingUniformAPIOverirdeTest::releaseResource() 9348 { 9349 m_goku_buffer.release(); 9350 } 9351 9352 /** Constructor 9353 * 9354 * @param context Test context 9355 **/ 9356 BindingUniformGlobalBlockTest::BindingUniformGlobalBlockTest(deqp::Context& context) 9357 : NegativeTestBase(context, "binding_uniform_global_block", 9358 "Test verifies that global uniform cannot be qualified with binding") 9359 { 9360 /* Nothing to be done here */ 9361 } 9362 9363 /** Prepare source for given shader stage 9364 * 9365 * @param in_stage Shader stage, compute shader will use 430 9366 * @param in_use_version_400 Select if 400 or 420 should be used 9367 * @param out_source Prepared shader source instance 9368 **/ 9369 void BindingUniformGlobalBlockTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 9370 Utils::shaderSource& out_source) 9371 { 9372 static const GLchar* verification_snippet = " if (vec4(0, 0, 1, 1) != uni_test)\n" 9373 " {\n" 9374 " result = vec4(1, 0, 0, 1);\n" 9375 " }\n"; 9376 9377 static const GLchar* uniform_definition = "layout(binding = 0) uniform vec4 uni_test;\n"; 9378 9379 static const GLchar* compute_shader_template = 9380 "VERSION\n" 9381 "\n" 9382 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 9383 "\n" 9384 "writeonly uniform image2D uni_image;\n" 9385 "\n" 9386 "UNIFORM_DEFINITION\n" 9387 "\n" 9388 "void main()\n" 9389 "{\n" 9390 " vec4 result = vec4(0, 1, 0, 1);\n" 9391 "\n" 9392 "VERIFICATION" 9393 "\n" 9394 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 9395 "}\n" 9396 "\n"; 9397 9398 static const GLchar* fragment_shader_template = "VERSION\n" 9399 "\n" 9400 "in vec4 gs_fs_result;\n" 9401 "out vec4 fs_out_result;\n" 9402 "\n" 9403 "UNIFORM_DEFINITION\n" 9404 "\n" 9405 "void main()\n" 9406 "{\n" 9407 " vec4 result = vec4(0, 1, 0, 1);\n" 9408 "\n" 9409 "VERIFICATION" 9410 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 9411 " {\n" 9412 " result = vec4(1, 0, 0, 1);\n" 9413 " }\n" 9414 "\n" 9415 " fs_out_result = result;\n" 9416 "}\n" 9417 "\n"; 9418 9419 static const GLchar* geometry_shader_template = "VERSION\n" 9420 "\n" 9421 "layout(points) in;\n" 9422 "layout(triangle_strip, max_vertices = 4) out;\n" 9423 "\n" 9424 "in vec4 tes_gs_result[];\n" 9425 "out vec4 gs_fs_result;\n" 9426 "\n" 9427 "UNIFORM_DEFINITION\n" 9428 "\n" 9429 "void main()\n" 9430 "{\n" 9431 " vec4 result = vec4(0, 1, 0, 1);\n" 9432 "\n" 9433 "VERIFICATION" 9434 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 9435 " {\n" 9436 " result = vec4(1, 0, 0, 1);\n" 9437 " }\n" 9438 "\n" 9439 " gs_fs_result = result;\n" 9440 " gl_Position = vec4(-1, -1, 0, 1);\n" 9441 " EmitVertex();\n" 9442 " gs_fs_result = result;\n" 9443 " gl_Position = vec4(-1, 1, 0, 1);\n" 9444 " EmitVertex();\n" 9445 " gs_fs_result = result;\n" 9446 " gl_Position = vec4(1, -1, 0, 1);\n" 9447 " EmitVertex();\n" 9448 " gs_fs_result = result;\n" 9449 " gl_Position = vec4(1, 1, 0, 1);\n" 9450 " EmitVertex();\n" 9451 "}\n" 9452 "\n"; 9453 9454 static const GLchar* tess_ctrl_shader_template = 9455 "VERSION\n" 9456 "\n" 9457 "layout(vertices = 1) out;\n" 9458 "\n" 9459 "in vec4 vs_tcs_result[];\n" 9460 "out vec4 tcs_tes_result[];\n" 9461 "\n" 9462 "UNIFORM_DEFINITION\n" 9463 "\n" 9464 "void main()\n" 9465 "{\n" 9466 " vec4 result = vec4(0, 1, 0, 1);\n" 9467 "\n" 9468 "VERIFICATION" 9469 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 9470 " {\n" 9471 " result = vec4(1, 0, 0, 1);\n" 9472 " }\n" 9473 "\n" 9474 " tcs_tes_result[gl_InvocationID] = result;\n" 9475 "\n" 9476 " gl_TessLevelOuter[0] = 1.0;\n" 9477 " gl_TessLevelOuter[1] = 1.0;\n" 9478 " gl_TessLevelOuter[2] = 1.0;\n" 9479 " gl_TessLevelOuter[3] = 1.0;\n" 9480 " gl_TessLevelInner[0] = 1.0;\n" 9481 " gl_TessLevelInner[1] = 1.0;\n" 9482 "}\n" 9483 "\n"; 9484 9485 static const GLchar* tess_eval_shader_template = "VERSION\n" 9486 "\n" 9487 "layout(isolines, point_mode) in;\n" 9488 "\n" 9489 "in vec4 tcs_tes_result[];\n" 9490 "out vec4 tes_gs_result;\n" 9491 "\n" 9492 "UNIFORM_DEFINITION\n" 9493 "\n" 9494 "void main()\n" 9495 "{\n" 9496 " vec4 result = vec4(0, 1, 0, 1);\n" 9497 "\n" 9498 "VERIFICATION" 9499 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 9500 " {\n" 9501 " result = vec4(1, 0, 0, 1);\n" 9502 " }\n" 9503 "\n" 9504 " tes_gs_result = result;\n" 9505 "}\n" 9506 "\n"; 9507 9508 static const GLchar* vertex_shader_template = "VERSION\n" 9509 "\n" 9510 "out vec4 vs_tcs_result;\n" 9511 "\n" 9512 "UNIFORM_DEFINITION\n" 9513 "\n" 9514 "void main()\n" 9515 "{\n" 9516 " vec4 result = vec4(0, 1, 0, 1);\n" 9517 "\n" 9518 "VERIFICATION" 9519 "\n" 9520 " vs_tcs_result = result;\n" 9521 "}\n" 9522 "\n"; 9523 9524 const GLchar* shader_template = 0; 9525 9526 switch (in_stage) 9527 { 9528 case Utils::COMPUTE_SHADER: 9529 shader_template = compute_shader_template; 9530 break; 9531 case Utils::FRAGMENT_SHADER: 9532 shader_template = fragment_shader_template; 9533 break; 9534 case Utils::GEOMETRY_SHADER: 9535 shader_template = geometry_shader_template; 9536 break; 9537 case Utils::TESS_CTRL_SHADER: 9538 shader_template = tess_ctrl_shader_template; 9539 break; 9540 case Utils::TESS_EVAL_SHADER: 9541 shader_template = tess_eval_shader_template; 9542 break; 9543 case Utils::VERTEX_SHADER: 9544 shader_template = vertex_shader_template; 9545 break; 9546 default: 9547 TCU_FAIL("Invalid enum"); 9548 break; 9549 } 9550 9551 out_source.m_parts[0].m_code = shader_template; 9552 9553 size_t position = 0; 9554 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 9555 out_source.m_parts[0].m_code); 9556 9557 Utils::replaceToken("UNIFORM_DEFINITION", position, uniform_definition, out_source.m_parts[0].m_code); 9558 9559 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 9560 } 9561 9562 /** Constructor 9563 * 9564 * @param context Test context 9565 **/ 9566 BindingUniformInvalidTest::BindingUniformInvalidTest(deqp::Context& context) 9567 : NegativeTestBase(context, "binding_uniform_invalid", "Test verifies invalid binding values") 9568 { 9569 /* Nothing to be done here */ 9570 } 9571 9572 /** Set up next test case 9573 * 9574 * @param test_case_index Index of next test case 9575 * 9576 * @return false if there is no more test cases, true otherwise 9577 **/ 9578 bool BindingUniformInvalidTest::prepareNextTestCase(glw::GLuint test_case_index) 9579 { 9580 switch (test_case_index) 9581 { 9582 case (glw::GLuint)-1: 9583 m_case = TEST_CASES_MAX; 9584 break; 9585 case NEGATIVE_VALUE: 9586 case VARIABLE_NAME: 9587 case STD140: 9588 case MISSING: 9589 m_case = (TESTCASES)test_case_index; 9590 break; 9591 default: 9592 return false; 9593 } 9594 9595 return true; 9596 } 9597 9598 /** Prepare source for given shader stage 9599 * 9600 * @param in_stage Shader stage, compute shader will use 430 9601 * @param in_use_version_400 Select if 400 or 420 should be used 9602 * @param out_source Prepared shader source instance 9603 **/ 9604 void BindingUniformInvalidTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 9605 Utils::shaderSource& out_source) 9606 { 9607 static const GLchar* verification_snippet = " if (vec4(0, 0, 1, 1) != goku.gohan)\n" 9608 " {\n" 9609 " result = vec4(1, 0, 0, 1);\n" 9610 " }\n"; 9611 9612 static const GLchar* uniform_definition = "layout(std140, binding BINDING) uniform GOKU {\n" 9613 " vec4 gohan;\n" 9614 " vec4 goten;\n" 9615 "} goku;\n"; 9616 9617 static const GLchar* compute_shader_template = 9618 "VERSION\n" 9619 "\n" 9620 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 9621 "\n" 9622 "writeonly uniform image2D uni_image;\n" 9623 "\n" 9624 "UNIFORM_DEFINITION\n" 9625 "\n" 9626 "void main()\n" 9627 "{\n" 9628 " vec4 result = vec4(0, 1, 0, 1);\n" 9629 "\n" 9630 "VERIFICATION" 9631 "\n" 9632 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 9633 "}\n" 9634 "\n"; 9635 9636 static const GLchar* fragment_shader_template = "VERSION\n" 9637 "\n" 9638 "in vec4 gs_fs_result;\n" 9639 "out vec4 fs_out_result;\n" 9640 "\n" 9641 "UNIFORM_DEFINITION\n" 9642 "\n" 9643 "void main()\n" 9644 "{\n" 9645 " vec4 result = vec4(0, 1, 0, 1);\n" 9646 "\n" 9647 "VERIFICATION" 9648 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 9649 " {\n" 9650 " result = vec4(1, 0, 0, 1);\n" 9651 " }\n" 9652 "\n" 9653 " fs_out_result = result;\n" 9654 "}\n" 9655 "\n"; 9656 9657 static const GLchar* geometry_shader_template = "VERSION\n" 9658 "\n" 9659 "layout(points) in;\n" 9660 "layout(triangle_strip, max_vertices = 4) out;\n" 9661 "\n" 9662 "in vec4 tes_gs_result[];\n" 9663 "out vec4 gs_fs_result;\n" 9664 "\n" 9665 "UNIFORM_DEFINITION\n" 9666 "\n" 9667 "void main()\n" 9668 "{\n" 9669 " vec4 result = vec4(0, 1, 0, 1);\n" 9670 "\n" 9671 "VERIFICATION" 9672 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 9673 " {\n" 9674 " result = vec4(1, 0, 0, 1);\n" 9675 " }\n" 9676 "\n" 9677 " gs_fs_result = result;\n" 9678 " gl_Position = vec4(-1, -1, 0, 1);\n" 9679 " EmitVertex();\n" 9680 " gs_fs_result = result;\n" 9681 " gl_Position = vec4(-1, 1, 0, 1);\n" 9682 " EmitVertex();\n" 9683 " gs_fs_result = result;\n" 9684 " gl_Position = vec4(1, -1, 0, 1);\n" 9685 " EmitVertex();\n" 9686 " gs_fs_result = result;\n" 9687 " gl_Position = vec4(1, 1, 0, 1);\n" 9688 " EmitVertex();\n" 9689 "}\n" 9690 "\n"; 9691 9692 static const GLchar* tess_ctrl_shader_template = 9693 "VERSION\n" 9694 "\n" 9695 "layout(vertices = 1) out;\n" 9696 "\n" 9697 "in vec4 vs_tcs_result[];\n" 9698 "out vec4 tcs_tes_result[];\n" 9699 "\n" 9700 "UNIFORM_DEFINITION\n" 9701 "\n" 9702 "void main()\n" 9703 "{\n" 9704 " vec4 result = vec4(0, 1, 0, 1);\n" 9705 "\n" 9706 "VERIFICATION" 9707 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 9708 " {\n" 9709 " result = vec4(1, 0, 0, 1);\n" 9710 " }\n" 9711 "\n" 9712 " tcs_tes_result[gl_InvocationID] = result;\n" 9713 "\n" 9714 " gl_TessLevelOuter[0] = 1.0;\n" 9715 " gl_TessLevelOuter[1] = 1.0;\n" 9716 " gl_TessLevelOuter[2] = 1.0;\n" 9717 " gl_TessLevelOuter[3] = 1.0;\n" 9718 " gl_TessLevelInner[0] = 1.0;\n" 9719 " gl_TessLevelInner[1] = 1.0;\n" 9720 "}\n" 9721 "\n"; 9722 9723 static const GLchar* tess_eval_shader_template = "VERSION\n" 9724 "\n" 9725 "layout(isolines, point_mode) in;\n" 9726 "\n" 9727 "in vec4 tcs_tes_result[];\n" 9728 "out vec4 tes_gs_result;\n" 9729 "\n" 9730 "UNIFORM_DEFINITION\n" 9731 "\n" 9732 "void main()\n" 9733 "{\n" 9734 " vec4 result = vec4(0, 1, 0, 1);\n" 9735 "\n" 9736 "VERIFICATION" 9737 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 9738 " {\n" 9739 " result = vec4(1, 0, 0, 1);\n" 9740 " }\n" 9741 "\n" 9742 " tes_gs_result = result;\n" 9743 "}\n" 9744 "\n"; 9745 9746 static const GLchar* vertex_shader_template = "VERSION\n" 9747 "\n" 9748 "out vec4 vs_tcs_result;\n" 9749 "\n" 9750 "UNIFORM_DEFINITION\n" 9751 "\n" 9752 "void main()\n" 9753 "{\n" 9754 " vec4 result = vec4(0, 1, 0, 1);\n" 9755 "\n" 9756 "VERIFICATION" 9757 "\n" 9758 " vs_tcs_result = result;\n" 9759 "}\n" 9760 "\n"; 9761 9762 const GLchar* shader_template = 0; 9763 9764 switch (in_stage) 9765 { 9766 case Utils::COMPUTE_SHADER: 9767 shader_template = compute_shader_template; 9768 break; 9769 case Utils::FRAGMENT_SHADER: 9770 shader_template = fragment_shader_template; 9771 break; 9772 case Utils::GEOMETRY_SHADER: 9773 shader_template = geometry_shader_template; 9774 break; 9775 case Utils::TESS_CTRL_SHADER: 9776 shader_template = tess_ctrl_shader_template; 9777 break; 9778 case Utils::TESS_EVAL_SHADER: 9779 shader_template = tess_eval_shader_template; 9780 break; 9781 case Utils::VERTEX_SHADER: 9782 shader_template = vertex_shader_template; 9783 break; 9784 default: 9785 TCU_FAIL("Invalid enum"); 9786 break; 9787 } 9788 9789 out_source.m_parts[0].m_code = shader_template; 9790 9791 size_t position = 0; 9792 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 9793 out_source.m_parts[0].m_code); 9794 9795 Utils::replaceToken("UNIFORM_DEFINITION", position, uniform_definition, out_source.m_parts[0].m_code); 9796 9797 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 9798 9799 Utils::replaceAllTokens("BINDING", getCaseString(m_case), out_source.m_parts[0].m_code); 9800 } 9801 9802 const GLchar* BindingUniformInvalidTest::getCaseString(TESTCASES test_case) 9803 { 9804 (void)test_case; 9805 const GLchar* binding = 0; 9806 9807 switch (m_case) 9808 { 9809 case NEGATIVE_VALUE: 9810 binding = "= -1"; 9811 break; 9812 case VARIABLE_NAME: 9813 binding = "= goku"; 9814 break; 9815 case STD140: 9816 binding = "= std140"; 9817 break; 9818 case MISSING: 9819 binding = ""; 9820 break; 9821 case TEST_CASES_MAX: 9822 binding = "= 0"; 9823 break; 9824 default: 9825 TCU_FAIL("Invalid enum"); 9826 } 9827 9828 return binding; 9829 } 9830 9831 /** Constructor 9832 * 9833 * @param context Test context 9834 **/ 9835 BindingSamplersTest::BindingSamplersTest(deqp::Context& context) 9836 : GLSLTestBase(context, "binding_samplers", "Test verifies smaplers binding") 9837 , m_goku_texture(context) 9838 , m_vegeta_texture(context) 9839 , m_trunks_texture(context) 9840 , m_buffer(context) 9841 { 9842 /* Nothing to be done here */ 9843 } 9844 9845 /** Set up next test case 9846 * 9847 * @param test_case_index Index of next test case 9848 * 9849 * @return false if there is no more test cases, true otherwise 9850 **/ 9851 bool BindingSamplersTest::prepareNextTestCase(glw::GLuint test_case_index) 9852 { 9853 switch (test_case_index) 9854 { 9855 case (glw::GLuint)-1: 9856 case 0: 9857 m_test_case = Utils::TEX_2D; 9858 break; 9859 case 1: 9860 m_test_case = Utils::TEX_BUFFER; 9861 break; 9862 case 2: 9863 m_test_case = Utils::TEX_2D_RECT; 9864 break; 9865 case 3: 9866 m_test_case = Utils::TEX_2D_ARRAY; 9867 break; 9868 case 4: 9869 m_test_case = Utils::TEX_3D; 9870 break; 9871 case 5: 9872 m_test_case = Utils::TEX_CUBE; 9873 break; 9874 case 6: 9875 m_test_case = Utils::TEX_1D; 9876 break; 9877 case 7: 9878 m_test_case = Utils::TEX_1D_ARRAY; 9879 break; 9880 default: 9881 return false; 9882 break; 9883 } 9884 9885 m_context.getTestContext().getLog() << tcu::TestLog::Message 9886 << "Tested texture type: " << Utils::getTextureTypeName(m_test_case) 9887 << tcu::TestLog::EndMessage; 9888 9889 return true; 9890 } 9891 9892 /** Prepare source for given shader stage 9893 * 9894 * @param in_stage Shader stage, compute shader will use 430 9895 * @param in_use_version_400 Select if 400 or 420 should be used 9896 * @param out_source Prepared shader source instance 9897 **/ 9898 void BindingSamplersTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 9899 Utils::shaderSource& out_source) 9900 { 9901 static const GLchar* uni_goku = "layout(binding = 0) uniform TYPE goku;\n"; 9902 9903 static const GLchar* uni_vegeta = "layout(binding = 1) uniform TYPE vegeta;\n"; 9904 9905 static const GLchar* uni_trunks = "layout(binding = 3) uniform TYPE trunks;\n\n"; 9906 9907 static const GLchar* verification_snippet = " TEX_COORD_TYPE tex_coord = TEX_COORD_TYPE(COORDINATES);\n" 9908 " vec4 goku_color = SAMPLING_FUNCTION(goku, tex_coord);\n" 9909 " vec4 vegeta_color = SAMPLING_FUNCTION(vegeta, tex_coord);\n" 9910 " vec4 trunks_color = SAMPLING_FUNCTION(trunks, tex_coord);\n" 9911 "\n" 9912 " if ((vec4(1, 0, 0, 0) != goku_color) ||\n" 9913 " (vec4(0, 1, 0, 0) != vegeta_color) ||\n" 9914 " (vec4(0, 0, 1, 0) != trunks_color) )\n" 9915 " {\n" 9916 " result = vec4(1, 0, 0, 1);\n" 9917 " }\n"; 9918 9919 static const GLchar* compute_shader_template = 9920 "VERSION\n" 9921 "\n" 9922 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 9923 "\n" 9924 "writeonly uniform image2D uni_image;\n" 9925 "\n" 9926 "UNI_GOKU\n" 9927 "UNI_VEGETA\n" 9928 "UNI_TRUNKS\n" 9929 "\n" 9930 "void main()\n" 9931 "{\n" 9932 " vec4 result = vec4(0, 1, 0, 1);\n" 9933 "\n" 9934 "VERIFICATION" 9935 "\n" 9936 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 9937 "}\n" 9938 "\n"; 9939 9940 static const GLchar* fragment_shader_template = "VERSION\n" 9941 "\n" 9942 "in vec4 gs_fs_result;\n" 9943 "out vec4 fs_out_result;\n" 9944 "\n" 9945 "UNI_GOKU\n" 9946 "UNI_VEGETA\n" 9947 "UNI_TRUNKS\n" 9948 "\n" 9949 "void main()\n" 9950 "{\n" 9951 " vec4 result = vec4(0, 1, 0, 1);\n" 9952 "\n" 9953 "VERIFICATION" 9954 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 9955 " {\n" 9956 " result = vec4(1, 0, 0, 1);\n" 9957 " }\n" 9958 "\n" 9959 " fs_out_result = result;\n" 9960 "}\n" 9961 "\n"; 9962 9963 static const GLchar* geometry_shader_template = "VERSION\n" 9964 "\n" 9965 "layout(points) in;\n" 9966 "layout(triangle_strip, max_vertices = 4) out;\n" 9967 "\n" 9968 "in vec4 tes_gs_result[];\n" 9969 "out vec4 gs_fs_result;\n" 9970 "\n" 9971 "UNI_TRUNKS\n" 9972 "UNI_GOKU\n" 9973 "UNI_VEGETA\n" 9974 "\n" 9975 "void main()\n" 9976 "{\n" 9977 " vec4 result = vec4(0, 1, 0, 1);\n" 9978 "\n" 9979 "VERIFICATION" 9980 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 9981 " {\n" 9982 " result = vec4(1, 0, 0, 1);\n" 9983 " }\n" 9984 "\n" 9985 " gs_fs_result = result;\n" 9986 " gl_Position = vec4(-1, -1, 0, 1);\n" 9987 " EmitVertex();\n" 9988 " gs_fs_result = result;\n" 9989 " gl_Position = vec4(-1, 1, 0, 1);\n" 9990 " EmitVertex();\n" 9991 " gs_fs_result = result;\n" 9992 " gl_Position = vec4(1, -1, 0, 1);\n" 9993 " EmitVertex();\n" 9994 " gs_fs_result = result;\n" 9995 " gl_Position = vec4(1, 1, 0, 1);\n" 9996 " EmitVertex();\n" 9997 "}\n" 9998 "\n"; 9999 10000 static const GLchar* tess_ctrl_shader_template = 10001 "VERSION\n" 10002 "\n" 10003 "layout(vertices = 1) out;\n" 10004 "\n" 10005 "in vec4 vs_tcs_result[];\n" 10006 "out vec4 tcs_tes_result[];\n" 10007 "\n" 10008 "UNI_VEGETA\n" 10009 "UNI_TRUNKS\n" 10010 "UNI_GOKU\n" 10011 "\n" 10012 "void main()\n" 10013 "{\n" 10014 " vec4 result = vec4(0, 1, 0, 1);\n" 10015 "\n" 10016 "VERIFICATION" 10017 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 10018 " {\n" 10019 " result = vec4(1, 0, 0, 1);\n" 10020 " }\n" 10021 "\n" 10022 " tcs_tes_result[gl_InvocationID] = result;\n" 10023 "\n" 10024 " gl_TessLevelOuter[0] = 1.0;\n" 10025 " gl_TessLevelOuter[1] = 1.0;\n" 10026 " gl_TessLevelOuter[2] = 1.0;\n" 10027 " gl_TessLevelOuter[3] = 1.0;\n" 10028 " gl_TessLevelInner[0] = 1.0;\n" 10029 " gl_TessLevelInner[1] = 1.0;\n" 10030 "}\n" 10031 "\n"; 10032 10033 static const GLchar* tess_eval_shader_template = "VERSION\n" 10034 "\n" 10035 "layout(isolines, point_mode) in;\n" 10036 "\n" 10037 "in vec4 tcs_tes_result[];\n" 10038 "out vec4 tes_gs_result;\n" 10039 "\n" 10040 "UNI_GOKU\n" 10041 "UNI_TRUNKS\n" 10042 "UNI_VEGETA\n" 10043 "\n" 10044 "void main()\n" 10045 "{\n" 10046 " vec4 result = vec4(0, 1, 0, 1);\n" 10047 "\n" 10048 "VERIFICATION" 10049 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 10050 " {\n" 10051 " result = vec4(1, 0, 0, 1);\n" 10052 " }\n" 10053 "\n" 10054 " tes_gs_result = result;\n" 10055 "}\n" 10056 "\n"; 10057 10058 static const GLchar* vertex_shader_template = "VERSION\n" 10059 "\n" 10060 "out vec4 vs_tcs_result;\n" 10061 "\n" 10062 "UNI_TRUNKS\n" 10063 "UNI_VEGETA\n" 10064 "UNI_GOKU\n" 10065 "\n" 10066 "void main()\n" 10067 "{\n" 10068 " vec4 result = vec4(0, 1, 0, 1);\n" 10069 "\n" 10070 "VERIFICATION" 10071 "\n" 10072 " vs_tcs_result = result;\n" 10073 "}\n" 10074 "\n"; 10075 10076 const Utils::TYPES base_tex_coord_type = (Utils::TEX_BUFFER == m_test_case) ? Utils::INT : Utils::FLOAT; 10077 const GLchar* coordinates = 0; 10078 GLuint n_coordinates = Utils::getNumberOfCoordinates(m_test_case); 10079 const GLchar* shader_template = 0; 10080 const GLchar* sampler_type = Utils::getSamplerType(m_test_case); 10081 const GLchar* sampling_function = (Utils::TEX_BUFFER == m_test_case) ? "texelFetch" : "texture"; 10082 const GLchar* tex_coord_type = Utils::getTypeName(base_tex_coord_type, 1 /* n_columns */, n_coordinates); 10083 10084 switch (in_stage) 10085 { 10086 case Utils::COMPUTE_SHADER: 10087 shader_template = compute_shader_template; 10088 break; 10089 case Utils::FRAGMENT_SHADER: 10090 shader_template = fragment_shader_template; 10091 break; 10092 case Utils::GEOMETRY_SHADER: 10093 shader_template = geometry_shader_template; 10094 break; 10095 case Utils::TESS_CTRL_SHADER: 10096 shader_template = tess_ctrl_shader_template; 10097 break; 10098 case Utils::TESS_EVAL_SHADER: 10099 shader_template = tess_eval_shader_template; 10100 break; 10101 case Utils::VERTEX_SHADER: 10102 shader_template = vertex_shader_template; 10103 break; 10104 default: 10105 TCU_FAIL("Invalid enum"); 10106 break; 10107 } 10108 10109 switch (n_coordinates) 10110 { 10111 case 1: 10112 coordinates = "0"; 10113 break; 10114 case 2: 10115 coordinates = "0, 0"; 10116 break; 10117 case 3: 10118 coordinates = "0, 0, 0"; 10119 break; 10120 case 4: 10121 coordinates = "0, 0, 0, 0"; 10122 break; 10123 } 10124 10125 out_source.m_parts[0].m_code = shader_template; 10126 10127 size_t position = 0; 10128 10129 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 10130 out_source.m_parts[0].m_code); 10131 10132 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 10133 10134 position -= strlen(verification_snippet); 10135 10136 Utils::replaceToken("COORDINATES", position, coordinates, out_source.m_parts[0].m_code); 10137 10138 Utils::replaceAllTokens("SAMPLING_FUNCTION", sampling_function, out_source.m_parts[0].m_code); 10139 10140 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 10141 10142 Utils::replaceAllTokens("UNI_VEGETA", uni_vegeta, out_source.m_parts[0].m_code); 10143 10144 Utils::replaceAllTokens("UNI_TRUNKS", uni_trunks, out_source.m_parts[0].m_code); 10145 10146 Utils::replaceAllTokens("TEX_COORD_TYPE", tex_coord_type, out_source.m_parts[0].m_code); 10147 10148 Utils::replaceAllTokens("TYPE", sampler_type, out_source.m_parts[0].m_code); 10149 } 10150 10151 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 10152 * 10153 * @param program Current program 10154 **/ 10155 void BindingSamplersTest::prepareUniforms(Utils::program& program) 10156 { 10157 (void)program; 10158 static const GLuint goku_data = 0x000000ff; 10159 static const GLuint vegeta_data = 0x0000ff00; 10160 static const GLuint trunks_data = 0x00ff0000; 10161 10162 prepareTexture(m_goku_texture, m_test_case, goku_data); 10163 prepareTexture(m_vegeta_texture, m_test_case, vegeta_data); 10164 prepareTexture(m_trunks_texture, m_test_case, trunks_data); 10165 10166 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10167 10168 gl.activeTexture(GL_TEXTURE0); 10169 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 10170 10171 m_goku_texture.bind(); 10172 10173 gl.activeTexture(GL_TEXTURE1); 10174 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 10175 10176 m_vegeta_texture.bind(); 10177 10178 gl.activeTexture(GL_TEXTURE3); 10179 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 10180 10181 m_trunks_texture.bind(); 10182 } 10183 10184 /** Overwrite of releaseResource method, release extra buffer and texture 10185 * 10186 * @param ignored 10187 **/ 10188 void BindingSamplersTest::releaseResource() 10189 { 10190 m_goku_texture.release(); 10191 m_vegeta_texture.release(); 10192 m_trunks_texture.release(); 10193 m_buffer.release(); 10194 } 10195 10196 /** Prepare texture of given type filled with given color 10197 * 10198 * @param texture Texture 10199 * @param texture_type Type of texture 10200 * @param color Color 10201 **/ 10202 void BindingSamplersTest::prepareTexture(Utils::texture& texture, Utils::TEXTURE_TYPES texture_type, glw::GLuint color) 10203 { 10204 (void)texture_type; 10205 static const GLuint width = 16; 10206 static const GLuint height = 16; 10207 static const GLuint depth = 1; 10208 10209 std::vector<GLuint> texture_data; 10210 texture_data.resize(width * height); 10211 10212 for (GLuint i = 0; i < texture_data.size(); ++i) 10213 { 10214 texture_data[i] = color; 10215 } 10216 10217 if (Utils::TEX_BUFFER != m_test_case) 10218 { 10219 texture.create(width, height, depth, GL_RGBA8, m_test_case); 10220 10221 texture.update(width, height, depth, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 10222 } 10223 else 10224 { 10225 m_buffer.generate(GL_TEXTURE_BUFFER); 10226 m_buffer.update(texture_data.size(), &texture_data[0], GL_STATIC_DRAW); 10227 10228 texture.createBuffer(GL_RGBA8, m_buffer.m_id); 10229 } 10230 } 10231 10232 /** Constructor 10233 * 10234 * @param context Test context 10235 **/ 10236 BindingSamplerSingleTest::BindingSamplerSingleTest(deqp::Context& context) 10237 : GLSLTestBase(context, "binding_sampler_single", "Test verifies sampler binding"), m_goku_texture(context) 10238 { 10239 /* Nothing to be done here */ 10240 } 10241 10242 /** Set up next test case 10243 * 10244 * @param test_case_index Index of next test case 10245 * 10246 * @return false if there is no more test cases, true otherwise 10247 **/ 10248 bool BindingSamplerSingleTest::prepareNextTestCase(glw::GLuint test_case_index) 10249 { 10250 switch (test_case_index) 10251 { 10252 case (glw::GLuint)-1: 10253 case 0: 10254 m_test_stage = Utils::VERTEX_SHADER; 10255 break; 10256 case 1: 10257 m_test_stage = Utils::TESS_CTRL_SHADER; 10258 break; 10259 case 2: 10260 m_test_stage = Utils::TESS_EVAL_SHADER; 10261 break; 10262 case 3: 10263 m_test_stage = Utils::GEOMETRY_SHADER; 10264 break; 10265 case 4: 10266 m_test_stage = Utils::FRAGMENT_SHADER; 10267 break; 10268 default: 10269 return false; 10270 break; 10271 } 10272 10273 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Tested stage: " 10274 << Utils::getShaderStageName((Utils::SHADER_STAGES)m_test_stage) 10275 << tcu::TestLog::EndMessage; 10276 10277 return true; 10278 } 10279 10280 /** Prepare source for given shader stage 10281 * 10282 * @param in_stage Shader stage, compute shader will use 430 10283 * @param in_use_version_400 Select if 400 or 420 should be used 10284 * @param out_source Prepared shader source instance 10285 **/ 10286 void BindingSamplerSingleTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 10287 Utils::shaderSource& out_source) 10288 { 10289 static const GLchar* uni_goku_with_binding = "layout(binding = 2) uniform sampler2D goku;\n"; 10290 10291 static const GLchar* uni_goku_no_binding = "uniform sampler2D goku;\n"; 10292 10293 static const GLchar* verification_snippet = " vec4 goku_color = texture(goku, vec2(0,0));\n" 10294 "\n" 10295 " if (vec4(1, 0, 0, 0) != goku_color)\n" 10296 " {\n" 10297 " result = vec4(1, 0, 0, 1);\n" 10298 " }\n"; 10299 10300 static const GLchar* compute_shader_template = 10301 "VERSION\n" 10302 "\n" 10303 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 10304 "\n" 10305 "writeonly uniform image2D uni_image;\n" 10306 "\n" 10307 "UNI_GOKU\n" 10308 "\n" 10309 "void main()\n" 10310 "{\n" 10311 " vec4 result = vec4(0, 1, 0, 1);\n" 10312 "\n" 10313 "VERIFICATION" 10314 "\n" 10315 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 10316 "}\n" 10317 "\n"; 10318 10319 static const GLchar* fragment_shader_template = "VERSION\n" 10320 "\n" 10321 "in vec4 gs_fs_result;\n" 10322 "out vec4 fs_out_result;\n" 10323 "\n" 10324 "UNI_GOKU\n" 10325 "\n" 10326 "void main()\n" 10327 "{\n" 10328 " vec4 result = vec4(0, 1, 0, 1);\n" 10329 "\n" 10330 "VERIFICATION" 10331 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 10332 " {\n" 10333 " result = vec4(1, 0, 0, 1);\n" 10334 " }\n" 10335 "\n" 10336 " fs_out_result = result;\n" 10337 "}\n" 10338 "\n"; 10339 10340 static const GLchar* geometry_shader_template = "VERSION\n" 10341 "\n" 10342 "layout(points) in;\n" 10343 "layout(triangle_strip, max_vertices = 4) out;\n" 10344 "\n" 10345 "in vec4 tes_gs_result[];\n" 10346 "out vec4 gs_fs_result;\n" 10347 "\n" 10348 "UNI_GOKU\n" 10349 "\n" 10350 "void main()\n" 10351 "{\n" 10352 " vec4 result = vec4(0, 1, 0, 1);\n" 10353 "\n" 10354 "VERIFICATION" 10355 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 10356 " {\n" 10357 " result = vec4(1, 0, 0, 1);\n" 10358 " }\n" 10359 "\n" 10360 " gs_fs_result = result;\n" 10361 " gl_Position = vec4(-1, -1, 0, 1);\n" 10362 " EmitVertex();\n" 10363 " gs_fs_result = result;\n" 10364 " gl_Position = vec4(-1, 1, 0, 1);\n" 10365 " EmitVertex();\n" 10366 " gs_fs_result = result;\n" 10367 " gl_Position = vec4(1, -1, 0, 1);\n" 10368 " EmitVertex();\n" 10369 " gs_fs_result = result;\n" 10370 " gl_Position = vec4(1, 1, 0, 1);\n" 10371 " EmitVertex();\n" 10372 "}\n" 10373 "\n"; 10374 10375 static const GLchar* tess_ctrl_shader_template = 10376 "VERSION\n" 10377 "\n" 10378 "layout(vertices = 1) out;\n" 10379 "\n" 10380 "in vec4 vs_tcs_result[];\n" 10381 "out vec4 tcs_tes_result[];\n" 10382 "\n" 10383 "UNI_GOKU\n" 10384 "\n" 10385 "void main()\n" 10386 "{\n" 10387 " vec4 result = vec4(0, 1, 0, 1);\n" 10388 "\n" 10389 "VERIFICATION" 10390 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 10391 " {\n" 10392 " result = vec4(1, 0, 0, 1);\n" 10393 " }\n" 10394 "\n" 10395 " tcs_tes_result[gl_InvocationID] = result;\n" 10396 "\n" 10397 " gl_TessLevelOuter[0] = 1.0;\n" 10398 " gl_TessLevelOuter[1] = 1.0;\n" 10399 " gl_TessLevelOuter[2] = 1.0;\n" 10400 " gl_TessLevelOuter[3] = 1.0;\n" 10401 " gl_TessLevelInner[0] = 1.0;\n" 10402 " gl_TessLevelInner[1] = 1.0;\n" 10403 "}\n" 10404 "\n"; 10405 10406 static const GLchar* tess_eval_shader_template = "VERSION\n" 10407 "\n" 10408 "layout(isolines, point_mode) in;\n" 10409 "\n" 10410 "in vec4 tcs_tes_result[];\n" 10411 "out vec4 tes_gs_result;\n" 10412 "\n" 10413 "UNI_GOKU\n" 10414 "\n" 10415 "void main()\n" 10416 "{\n" 10417 " vec4 result = vec4(0, 1, 0, 1);\n" 10418 "\n" 10419 "VERIFICATION" 10420 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 10421 " {\n" 10422 " result = vec4(1, 0, 0, 1);\n" 10423 " }\n" 10424 "\n" 10425 " tes_gs_result = result;\n" 10426 "}\n" 10427 "\n"; 10428 10429 static const GLchar* vertex_shader_template = "VERSION\n" 10430 "\n" 10431 "out vec4 vs_tcs_result;\n" 10432 "\n" 10433 "UNI_GOKU\n" 10434 "\n" 10435 "void main()\n" 10436 "{\n" 10437 " vec4 result = vec4(0, 1, 0, 1);\n" 10438 "\n" 10439 "VERIFICATION" 10440 "\n" 10441 " vs_tcs_result = result;\n" 10442 "}\n" 10443 "\n"; 10444 10445 const GLchar* shader_template = 0; 10446 const GLchar* uniform_definition = uni_goku_no_binding; 10447 10448 switch (in_stage) 10449 { 10450 case Utils::COMPUTE_SHADER: 10451 shader_template = compute_shader_template; 10452 uniform_definition = uni_goku_with_binding; 10453 break; 10454 case Utils::FRAGMENT_SHADER: 10455 shader_template = fragment_shader_template; 10456 break; 10457 case Utils::GEOMETRY_SHADER: 10458 shader_template = geometry_shader_template; 10459 break; 10460 case Utils::TESS_CTRL_SHADER: 10461 shader_template = tess_ctrl_shader_template; 10462 break; 10463 case Utils::TESS_EVAL_SHADER: 10464 shader_template = tess_eval_shader_template; 10465 break; 10466 case Utils::VERTEX_SHADER: 10467 shader_template = vertex_shader_template; 10468 break; 10469 default: 10470 TCU_FAIL("Invalid enum"); 10471 break; 10472 } 10473 10474 if (in_stage == m_test_stage) 10475 { 10476 uniform_definition = uni_goku_with_binding; 10477 } 10478 10479 out_source.m_parts[0].m_code = shader_template; 10480 10481 size_t position = 0; 10482 10483 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 10484 out_source.m_parts[0].m_code); 10485 10486 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 10487 10488 Utils::replaceAllTokens("UNI_GOKU", uniform_definition, out_source.m_parts[0].m_code); 10489 } 10490 10491 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 10492 * 10493 * @param program Current program 10494 **/ 10495 void BindingSamplerSingleTest::prepareUniforms(Utils::program& program) 10496 { 10497 (void)program; 10498 static const GLuint goku_data = 0x000000ff; 10499 10500 m_goku_texture.create(16, 16, GL_RGBA8); 10501 10502 std::vector<GLuint> texture_data; 10503 texture_data.resize(16 * 16); 10504 10505 for (GLuint i = 0; i < texture_data.size(); ++i) 10506 { 10507 texture_data[i] = goku_data; 10508 } 10509 10510 m_goku_texture.update(16, 16, 0 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 10511 10512 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10513 10514 gl.activeTexture(GL_TEXTURE2); 10515 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 10516 10517 m_goku_texture.bind(); 10518 } 10519 10520 /** Overwrite of releaseResource method, release extra texture 10521 * 10522 * @param ignored 10523 **/ 10524 void BindingSamplerSingleTest::releaseResource() 10525 { 10526 m_goku_texture.release(); 10527 } 10528 10529 /** Constructor 10530 * 10531 * @param context Test context 10532 **/ 10533 BindingSamplerArrayTest::BindingSamplerArrayTest(deqp::Context& context) 10534 : GLSLTestBase(context, "binding_sampler_array", "Test verifies binding of sampler arrays") 10535 , m_goku_00_texture(context) 10536 , m_goku_01_texture(context) 10537 , m_goku_02_texture(context) 10538 , m_goku_03_texture(context) 10539 , m_goku_04_texture(context) 10540 , m_goku_05_texture(context) 10541 , m_goku_06_texture(context) 10542 { 10543 /* Nothing to be done here */ 10544 } 10545 10546 /** Prepare source for given shader stage 10547 * 10548 * @param in_stage Shader stage, compute shader will use 430 10549 * @param in_use_version_400 Select if 400 or 420 should be used 10550 * @param out_source Prepared shader source instance 10551 **/ 10552 void BindingSamplerArrayTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 10553 Utils::shaderSource& out_source) 10554 { 10555 static const GLchar* uni_goku = "layout(binding = 1) uniform sampler2D goku[7];\n"; 10556 10557 static const GLchar* verification_snippet = " vec4 color[7];\n" 10558 "\n" 10559 " for (uint i = 0u; i < 7; ++i)\n" 10560 " {\n" 10561 " color[i] = texture(goku[i], vec2(0, 0));\n" 10562 " }\n" 10563 "\n" 10564 " if ((vec4(0, 0, 0, 0) != color[0]) ||\n" 10565 " (vec4(0, 0, 0, 1) != color[1]) ||\n" 10566 " (vec4(0, 0, 1, 0) != color[2]) ||\n" 10567 " (vec4(0, 0, 1, 1) != color[3]) ||\n" 10568 " (vec4(0, 1, 0, 0) != color[4]) ||\n" 10569 " (vec4(0, 1, 0, 1) != color[5]) ||\n" 10570 " (vec4(0, 1, 1, 0) != color[6]) )\n" 10571 " {\n" 10572 " result = vec4(1, 0, 0, 1);\n" 10573 " }\n"; 10574 10575 static const GLchar* compute_shader_template = 10576 "VERSION\n" 10577 "\n" 10578 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 10579 "\n" 10580 "writeonly uniform image2D uni_image;\n" 10581 "\n" 10582 "UNI_GOKU\n" 10583 "\n" 10584 "void main()\n" 10585 "{\n" 10586 " vec4 result = vec4(0, 1, 0, 1);\n" 10587 "\n" 10588 "VERIFICATION" 10589 "\n" 10590 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 10591 "}\n" 10592 "\n"; 10593 10594 static const GLchar* fragment_shader_template = "VERSION\n" 10595 "\n" 10596 "in vec4 gs_fs_result;\n" 10597 "out vec4 fs_out_result;\n" 10598 "\n" 10599 "UNI_GOKU\n" 10600 "\n" 10601 "void main()\n" 10602 "{\n" 10603 " vec4 result = vec4(0, 1, 0, 1);\n" 10604 "\n" 10605 "VERIFICATION" 10606 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 10607 " {\n" 10608 " result = vec4(1, 0, 0, 1);\n" 10609 " }\n" 10610 "\n" 10611 " fs_out_result = result;\n" 10612 "}\n" 10613 "\n"; 10614 10615 static const GLchar* geometry_shader_template = "VERSION\n" 10616 "\n" 10617 "layout(points) in;\n" 10618 "layout(triangle_strip, max_vertices = 4) out;\n" 10619 "\n" 10620 "in vec4 tes_gs_result[];\n" 10621 "out vec4 gs_fs_result;\n" 10622 "\n" 10623 "UNI_GOKU\n" 10624 "\n" 10625 "void main()\n" 10626 "{\n" 10627 " vec4 result = vec4(0, 1, 0, 1);\n" 10628 "\n" 10629 "VERIFICATION" 10630 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 10631 " {\n" 10632 " result = vec4(1, 0, 0, 1);\n" 10633 " }\n" 10634 "\n" 10635 " gs_fs_result = result;\n" 10636 " gl_Position = vec4(-1, -1, 0, 1);\n" 10637 " EmitVertex();\n" 10638 " gs_fs_result = result;\n" 10639 " gl_Position = vec4(-1, 1, 0, 1);\n" 10640 " EmitVertex();\n" 10641 " gs_fs_result = result;\n" 10642 " gl_Position = vec4(1, -1, 0, 1);\n" 10643 " EmitVertex();\n" 10644 " gs_fs_result = result;\n" 10645 " gl_Position = vec4(1, 1, 0, 1);\n" 10646 " EmitVertex();\n" 10647 "}\n" 10648 "\n"; 10649 10650 static const GLchar* tess_ctrl_shader_template = 10651 "VERSION\n" 10652 "\n" 10653 "layout(vertices = 1) out;\n" 10654 "\n" 10655 "in vec4 vs_tcs_result[];\n" 10656 "out vec4 tcs_tes_result[];\n" 10657 "\n" 10658 "UNI_GOKU\n" 10659 "\n" 10660 "void main()\n" 10661 "{\n" 10662 " vec4 result = vec4(0, 1, 0, 1);\n" 10663 "\n" 10664 "VERIFICATION" 10665 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 10666 " {\n" 10667 " result = vec4(1, 0, 0, 1);\n" 10668 " }\n" 10669 "\n" 10670 " tcs_tes_result[gl_InvocationID] = result;\n" 10671 "\n" 10672 " gl_TessLevelOuter[0] = 1.0;\n" 10673 " gl_TessLevelOuter[1] = 1.0;\n" 10674 " gl_TessLevelOuter[2] = 1.0;\n" 10675 " gl_TessLevelOuter[3] = 1.0;\n" 10676 " gl_TessLevelInner[0] = 1.0;\n" 10677 " gl_TessLevelInner[1] = 1.0;\n" 10678 "}\n" 10679 "\n"; 10680 10681 static const GLchar* tess_eval_shader_template = "VERSION\n" 10682 "\n" 10683 "layout(isolines, point_mode) in;\n" 10684 "\n" 10685 "in vec4 tcs_tes_result[];\n" 10686 "out vec4 tes_gs_result;\n" 10687 "\n" 10688 "UNI_GOKU\n" 10689 "\n" 10690 "void main()\n" 10691 "{\n" 10692 " vec4 result = vec4(0, 1, 0, 1);\n" 10693 "\n" 10694 "VERIFICATION" 10695 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 10696 " {\n" 10697 " result = vec4(1, 0, 0, 1);\n" 10698 " }\n" 10699 "\n" 10700 " tes_gs_result = result;\n" 10701 "}\n" 10702 "\n"; 10703 10704 static const GLchar* vertex_shader_template = "VERSION\n" 10705 "\n" 10706 "out vec4 vs_tcs_result;\n" 10707 "\n" 10708 "UNI_GOKU\n" 10709 "\n" 10710 "void main()\n" 10711 "{\n" 10712 " vec4 result = vec4(0, 1, 0, 1);\n" 10713 "\n" 10714 "VERIFICATION" 10715 "\n" 10716 " vs_tcs_result = result;\n" 10717 "}\n" 10718 "\n"; 10719 10720 const GLchar* shader_template = 0; 10721 10722 switch (in_stage) 10723 { 10724 case Utils::COMPUTE_SHADER: 10725 shader_template = compute_shader_template; 10726 break; 10727 case Utils::FRAGMENT_SHADER: 10728 shader_template = fragment_shader_template; 10729 break; 10730 case Utils::GEOMETRY_SHADER: 10731 shader_template = geometry_shader_template; 10732 break; 10733 case Utils::TESS_CTRL_SHADER: 10734 shader_template = tess_ctrl_shader_template; 10735 break; 10736 case Utils::TESS_EVAL_SHADER: 10737 shader_template = tess_eval_shader_template; 10738 break; 10739 case Utils::VERTEX_SHADER: 10740 shader_template = vertex_shader_template; 10741 break; 10742 default: 10743 TCU_FAIL("Invalid enum"); 10744 break; 10745 } 10746 10747 out_source.m_parts[0].m_code = shader_template; 10748 10749 size_t position = 0; 10750 10751 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 10752 out_source.m_parts[0].m_code); 10753 10754 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 10755 10756 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 10757 } 10758 10759 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 10760 * 10761 * @param program Current program 10762 **/ 10763 void BindingSamplerArrayTest::prepareUniforms(Utils::program& program) 10764 { 10765 static const GLuint goku_data[7] = { 10766 0x00000000, 0xff000000, 0x00ff0000, 0xffff0000, 0x0000ff00, 0xff00ff00, 0x00ffff00, 10767 }; 10768 10769 static const GLuint binding_offset = 1; 10770 10771 Utils::texture* textures[7] = { 10772 &m_goku_00_texture, &m_goku_01_texture, &m_goku_02_texture, &m_goku_03_texture, 10773 &m_goku_04_texture, &m_goku_05_texture, &m_goku_06_texture, 10774 }; 10775 10776 std::vector<GLuint> texture_data; 10777 texture_data.resize(16 * 16); 10778 10779 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 10780 10781 for (GLuint i = 0; i < 7; ++i) 10782 { 10783 GLint expected_binding = i + binding_offset; 10784 10785 checkBinding(program, i, expected_binding); 10786 10787 gl.activeTexture(GL_TEXTURE0 + expected_binding); 10788 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 10789 10790 textures[i]->create(16, 16, GL_RGBA8); 10791 10792 for (GLuint j = 0; j < texture_data.size(); ++j) 10793 { 10794 texture_data[j] = goku_data[i]; 10795 } 10796 10797 textures[i]->update(16, 16, 0 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 10798 } 10799 } 10800 10801 /** Overwrite of releaseResource method, release extra textures 10802 * 10803 * @param ignored 10804 **/ 10805 void BindingSamplerArrayTest::releaseResource() 10806 { 10807 Utils::texture* textures[7] = { 10808 &m_goku_00_texture, &m_goku_01_texture, &m_goku_02_texture, &m_goku_03_texture, 10809 &m_goku_04_texture, &m_goku_05_texture, &m_goku_06_texture, 10810 }; 10811 10812 for (GLuint i = 0; i < 7; ++i) 10813 { 10814 textures[i]->release(); 10815 } 10816 } 10817 10818 /** Verifies that API reports correct uniform binding 10819 * 10820 * @param program Program 10821 * @param index Index of array element 10822 * @param expected_binding Expected binding 10823 **/ 10824 void BindingSamplerArrayTest::checkBinding(Utils::program& program, GLuint index, GLint expected_binding) 10825 { 10826 if (false == Utils::checkUniformArrayBinding(program, "goku", index, expected_binding)) 10827 { 10828 TCU_FAIL("Wrong binding reported by API"); 10829 } 10830 } 10831 10832 /** Constructor 10833 * 10834 * @param context Test context 10835 **/ 10836 BindingSamplerDefaultTest::BindingSamplerDefaultTest(deqp::Context& context) 10837 : APITestBase(context, "binding_sampler_default", "Test verifies default sampler binding") 10838 { 10839 /* Nothing to be done here */ 10840 } 10841 10842 /** Execute API call and verifies results 10843 * 10844 * @return true when results are positive, false otherwise 10845 **/ 10846 bool BindingSamplerDefaultTest::checkResults(Utils::program& program) 10847 { 10848 return Utils::checkUniformBinding(program, "goku", 0 /* expected_binding */); 10849 } 10850 10851 /** Prepare source for given shader stage 10852 * 10853 * @param in_stage Shader stage, compute shader will use 430 10854 * @param in_use_version_400 Select if 400 or 420 should be used 10855 * @param out_source Prepared shader source instance 10856 **/ 10857 void BindingSamplerDefaultTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 10858 Utils::shaderSource& out_source) 10859 { 10860 static const GLchar* uni_goku = "uniform sampler2D goku;\n"; 10861 10862 static const GLchar* verification_snippet = " vec4 color = texture(goku, vec2(0,0));\n" 10863 " if (vec4(1, 0, 0, 0) != color)\n" 10864 " {\n" 10865 " result = vec4(1, 0, 0, 1);\n" 10866 " }\n"; 10867 10868 static const GLchar* compute_shader_template = 10869 "VERSION\n" 10870 "\n" 10871 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 10872 "\n" 10873 "writeonly uniform image2D uni_image;\n" 10874 "\n" 10875 "UNI_GOKU\n" 10876 "\n" 10877 "void main()\n" 10878 "{\n" 10879 " vec4 result = vec4(0, 1, 0, 1);\n" 10880 "\n" 10881 "VERIFICATION" 10882 "\n" 10883 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 10884 "}\n" 10885 "\n"; 10886 10887 static const GLchar* fragment_shader_template = "VERSION\n" 10888 "\n" 10889 "in vec4 gs_fs_result;\n" 10890 "out vec4 fs_out_result;\n" 10891 "\n" 10892 "UNI_GOKU\n" 10893 "\n" 10894 "void main()\n" 10895 "{\n" 10896 " vec4 result = vec4(0, 1, 0, 1);\n" 10897 "\n" 10898 "VERIFICATION" 10899 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 10900 " {\n" 10901 " result = vec4(1, 0, 0, 1);\n" 10902 " }\n" 10903 "\n" 10904 " fs_out_result = result;\n" 10905 "}\n" 10906 "\n"; 10907 10908 static const GLchar* geometry_shader_template = "VERSION\n" 10909 "\n" 10910 "layout(points) in;\n" 10911 "layout(triangle_strip, max_vertices = 4) out;\n" 10912 "\n" 10913 "in vec4 tes_gs_result[];\n" 10914 "out vec4 gs_fs_result;\n" 10915 "\n" 10916 "UNI_GOKU\n" 10917 "\n" 10918 "void main()\n" 10919 "{\n" 10920 " vec4 result = vec4(0, 1, 0, 1);\n" 10921 "\n" 10922 "VERIFICATION" 10923 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 10924 " {\n" 10925 " result = vec4(1, 0, 0, 1);\n" 10926 " }\n" 10927 "\n" 10928 " gs_fs_result = result;\n" 10929 " gl_Position = vec4(-1, -1, 0, 1);\n" 10930 " EmitVertex();\n" 10931 " gs_fs_result = result;\n" 10932 " gl_Position = vec4(-1, 1, 0, 1);\n" 10933 " EmitVertex();\n" 10934 " gs_fs_result = result;\n" 10935 " gl_Position = vec4(1, -1, 0, 1);\n" 10936 " EmitVertex();\n" 10937 " gs_fs_result = result;\n" 10938 " gl_Position = vec4(1, 1, 0, 1);\n" 10939 " EmitVertex();\n" 10940 "}\n" 10941 "\n"; 10942 10943 static const GLchar* tess_ctrl_shader_template = 10944 "VERSION\n" 10945 "\n" 10946 "layout(vertices = 1) out;\n" 10947 "\n" 10948 "in vec4 vs_tcs_result[];\n" 10949 "out vec4 tcs_tes_result[];\n" 10950 "\n" 10951 "UNI_GOKU\n" 10952 "\n" 10953 "void main()\n" 10954 "{\n" 10955 " vec4 result = vec4(0, 1, 0, 1);\n" 10956 "\n" 10957 "VERIFICATION" 10958 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 10959 " {\n" 10960 " result = vec4(1, 0, 0, 1);\n" 10961 " }\n" 10962 "\n" 10963 " tcs_tes_result[gl_InvocationID] = result;\n" 10964 "\n" 10965 " gl_TessLevelOuter[0] = 1.0;\n" 10966 " gl_TessLevelOuter[1] = 1.0;\n" 10967 " gl_TessLevelOuter[2] = 1.0;\n" 10968 " gl_TessLevelOuter[3] = 1.0;\n" 10969 " gl_TessLevelInner[0] = 1.0;\n" 10970 " gl_TessLevelInner[1] = 1.0;\n" 10971 "}\n" 10972 "\n"; 10973 10974 static const GLchar* tess_eval_shader_template = "VERSION\n" 10975 "\n" 10976 "layout(isolines, point_mode) in;\n" 10977 "\n" 10978 "in vec4 tcs_tes_result[];\n" 10979 "out vec4 tes_gs_result;\n" 10980 "\n" 10981 "UNI_GOKU\n" 10982 "\n" 10983 "void main()\n" 10984 "{\n" 10985 " vec4 result = vec4(0, 1, 0, 1);\n" 10986 "\n" 10987 "VERIFICATION" 10988 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 10989 " {\n" 10990 " result = vec4(1, 0, 0, 1);\n" 10991 " }\n" 10992 "\n" 10993 " tes_gs_result = result;\n" 10994 "}\n" 10995 "\n"; 10996 10997 static const GLchar* vertex_shader_template = "VERSION\n" 10998 "\n" 10999 "out vec4 vs_tcs_result;\n" 11000 "\n" 11001 "UNI_GOKU\n" 11002 "\n" 11003 "void main()\n" 11004 "{\n" 11005 " vec4 result = vec4(0, 1, 0, 1);\n" 11006 "\n" 11007 "VERIFICATION" 11008 "\n" 11009 " vs_tcs_result = result;\n" 11010 "}\n" 11011 "\n"; 11012 11013 const GLchar* shader_template = 0; 11014 11015 switch (in_stage) 11016 { 11017 case Utils::COMPUTE_SHADER: 11018 shader_template = compute_shader_template; 11019 break; 11020 case Utils::FRAGMENT_SHADER: 11021 shader_template = fragment_shader_template; 11022 break; 11023 case Utils::GEOMETRY_SHADER: 11024 shader_template = geometry_shader_template; 11025 break; 11026 case Utils::TESS_CTRL_SHADER: 11027 shader_template = tess_ctrl_shader_template; 11028 break; 11029 case Utils::TESS_EVAL_SHADER: 11030 shader_template = tess_eval_shader_template; 11031 break; 11032 case Utils::VERTEX_SHADER: 11033 shader_template = vertex_shader_template; 11034 break; 11035 default: 11036 TCU_FAIL("Invalid enum"); 11037 break; 11038 } 11039 11040 out_source.m_parts[0].m_code = shader_template; 11041 11042 size_t position = 0; 11043 11044 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 11045 out_source.m_parts[0].m_code); 11046 11047 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 11048 11049 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 11050 } 11051 11052 /** Constructor 11053 * 11054 * @param context Test context 11055 **/ 11056 BindingSamplerAPIOverrideTest::BindingSamplerAPIOverrideTest(deqp::Context& context) 11057 : GLSLTestBase(context, "binding_sampler_api_override", "Verifies that API can override sampler binding") 11058 , m_goku_texture(context) 11059 { 11060 /* Nothing to be done here */ 11061 } 11062 11063 /** Prepare source for given shader stage 11064 * 11065 * @param in_stage Shader stage, compute shader will use 430 11066 * @param in_use_version_400 Select if 400 or 420 should be used 11067 * @param out_source Prepared shader source instance 11068 **/ 11069 void BindingSamplerAPIOverrideTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 11070 Utils::shaderSource& out_source) 11071 { 11072 static const GLchar* uni_goku = "layout(binding = 2) uniform sampler2D goku;\n"; 11073 11074 static const GLchar* verification_snippet = " vec4 color = texture(goku, vec2(0,0));\n" 11075 " if (vec4(1, 0, 0, 0) != color)\n" 11076 " {\n" 11077 " result = vec4(1, 0, 0, 1);\n" 11078 " }\n"; 11079 11080 static const GLchar* compute_shader_template = 11081 "VERSION\n" 11082 "\n" 11083 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 11084 "\n" 11085 "writeonly uniform image2D uni_image;\n" 11086 "\n" 11087 "UNI_GOKU\n" 11088 "\n" 11089 "void main()\n" 11090 "{\n" 11091 " vec4 result = vec4(0, 1, 0, 1);\n" 11092 "\n" 11093 "VERIFICATION" 11094 "\n" 11095 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 11096 "}\n" 11097 "\n"; 11098 11099 static const GLchar* fragment_shader_template = "VERSION\n" 11100 "\n" 11101 "in vec4 gs_fs_result;\n" 11102 "out vec4 fs_out_result;\n" 11103 "\n" 11104 "UNI_GOKU\n" 11105 "\n" 11106 "void main()\n" 11107 "{\n" 11108 " vec4 result = vec4(0, 1, 0, 1);\n" 11109 "\n" 11110 "VERIFICATION" 11111 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 11112 " {\n" 11113 " result = vec4(1, 0, 0, 1);\n" 11114 " }\n" 11115 "\n" 11116 " fs_out_result = result;\n" 11117 "}\n" 11118 "\n"; 11119 11120 static const GLchar* geometry_shader_template = "VERSION\n" 11121 "\n" 11122 "layout(points) in;\n" 11123 "layout(triangle_strip, max_vertices = 4) out;\n" 11124 "\n" 11125 "in vec4 tes_gs_result[];\n" 11126 "out vec4 gs_fs_result;\n" 11127 "\n" 11128 "UNI_GOKU\n" 11129 "\n" 11130 "void main()\n" 11131 "{\n" 11132 " vec4 result = vec4(0, 1, 0, 1);\n" 11133 "\n" 11134 "VERIFICATION" 11135 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 11136 " {\n" 11137 " result = vec4(1, 0, 0, 1);\n" 11138 " }\n" 11139 "\n" 11140 " gs_fs_result = result;\n" 11141 " gl_Position = vec4(-1, -1, 0, 1);\n" 11142 " EmitVertex();\n" 11143 " gs_fs_result = result;\n" 11144 " gl_Position = vec4(-1, 1, 0, 1);\n" 11145 " EmitVertex();\n" 11146 " gs_fs_result = result;\n" 11147 " gl_Position = vec4(1, -1, 0, 1);\n" 11148 " EmitVertex();\n" 11149 " gs_fs_result = result;\n" 11150 " gl_Position = vec4(1, 1, 0, 1);\n" 11151 " EmitVertex();\n" 11152 "}\n" 11153 "\n"; 11154 11155 static const GLchar* tess_ctrl_shader_template = 11156 "VERSION\n" 11157 "\n" 11158 "layout(vertices = 1) out;\n" 11159 "\n" 11160 "in vec4 vs_tcs_result[];\n" 11161 "out vec4 tcs_tes_result[];\n" 11162 "\n" 11163 "UNI_GOKU\n" 11164 "\n" 11165 "void main()\n" 11166 "{\n" 11167 " vec4 result = vec4(0, 1, 0, 1);\n" 11168 "\n" 11169 "VERIFICATION" 11170 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 11171 " {\n" 11172 " result = vec4(1, 0, 0, 1);\n" 11173 " }\n" 11174 "\n" 11175 " tcs_tes_result[gl_InvocationID] = result;\n" 11176 "\n" 11177 " gl_TessLevelOuter[0] = 1.0;\n" 11178 " gl_TessLevelOuter[1] = 1.0;\n" 11179 " gl_TessLevelOuter[2] = 1.0;\n" 11180 " gl_TessLevelOuter[3] = 1.0;\n" 11181 " gl_TessLevelInner[0] = 1.0;\n" 11182 " gl_TessLevelInner[1] = 1.0;\n" 11183 "}\n" 11184 "\n"; 11185 11186 static const GLchar* tess_eval_shader_template = "VERSION\n" 11187 "\n" 11188 "layout(isolines, point_mode) in;\n" 11189 "\n" 11190 "in vec4 tcs_tes_result[];\n" 11191 "out vec4 tes_gs_result;\n" 11192 "\n" 11193 "UNI_GOKU\n" 11194 "\n" 11195 "void main()\n" 11196 "{\n" 11197 " vec4 result = vec4(0, 1, 0, 1);\n" 11198 "\n" 11199 "VERIFICATION" 11200 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 11201 " {\n" 11202 " result = vec4(1, 0, 0, 1);\n" 11203 " }\n" 11204 "\n" 11205 " tes_gs_result = result;\n" 11206 "}\n" 11207 "\n"; 11208 11209 static const GLchar* vertex_shader_template = "VERSION\n" 11210 "\n" 11211 "out vec4 vs_tcs_result;\n" 11212 "\n" 11213 "UNI_GOKU\n" 11214 "\n" 11215 "void main()\n" 11216 "{\n" 11217 " vec4 result = vec4(0, 1, 0, 1);\n" 11218 "\n" 11219 "VERIFICATION" 11220 "\n" 11221 " vs_tcs_result = result;\n" 11222 "}\n" 11223 "\n"; 11224 11225 const GLchar* shader_template = 0; 11226 11227 switch (in_stage) 11228 { 11229 case Utils::COMPUTE_SHADER: 11230 shader_template = compute_shader_template; 11231 break; 11232 case Utils::FRAGMENT_SHADER: 11233 shader_template = fragment_shader_template; 11234 break; 11235 case Utils::GEOMETRY_SHADER: 11236 shader_template = geometry_shader_template; 11237 break; 11238 case Utils::TESS_CTRL_SHADER: 11239 shader_template = tess_ctrl_shader_template; 11240 break; 11241 case Utils::TESS_EVAL_SHADER: 11242 shader_template = tess_eval_shader_template; 11243 break; 11244 case Utils::VERTEX_SHADER: 11245 shader_template = vertex_shader_template; 11246 break; 11247 default: 11248 TCU_FAIL("Invalid enum"); 11249 break; 11250 } 11251 11252 out_source.m_parts[0].m_code = shader_template; 11253 11254 size_t position = 0; 11255 11256 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 11257 out_source.m_parts[0].m_code); 11258 11259 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 11260 11261 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 11262 } 11263 11264 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 11265 * 11266 * @param program Current program 11267 **/ 11268 void BindingSamplerAPIOverrideTest::prepareUniforms(Utils::program& program) 11269 { 11270 static const GLuint goku_data = 0x000000ff; 11271 static const GLint new_binding = 11; 11272 11273 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 11274 11275 const GLint uniform_location = program.getUniformLocation("goku"); 11276 if (-1 == uniform_location) 11277 { 11278 TCU_FAIL("Uniform is inactive"); 11279 } 11280 11281 gl.uniform1i(uniform_location, new_binding); 11282 11283 GLint binding = -1; 11284 11285 gl.getUniformiv(program.m_program_object_id, uniform_location, &binding); 11286 GLU_EXPECT_NO_ERROR(gl.getError(), "getUniformiv"); 11287 11288 if (new_binding != binding) 11289 { 11290 TCU_FAIL("Wrong binding value"); 11291 return; 11292 } 11293 11294 m_goku_texture.create(16, 16, GL_RGBA8); 11295 11296 std::vector<GLuint> texture_data; 11297 texture_data.resize(16 * 16); 11298 11299 for (GLuint i = 0; i < texture_data.size(); ++i) 11300 { 11301 texture_data[i] = goku_data; 11302 } 11303 11304 m_goku_texture.update(16, 16, 0 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); 11305 11306 gl.activeTexture(GL_TEXTURE11); 11307 GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); 11308 11309 m_goku_texture.bind(); 11310 } 11311 11312 /** Overwrite of releaseResource method, release extra texture 11313 * 11314 * @param ignored 11315 **/ 11316 void BindingSamplerAPIOverrideTest::releaseResource() 11317 { 11318 m_goku_texture.release(); 11319 } 11320 11321 /** Constructor 11322 * 11323 * @param context Test context 11324 **/ 11325 BindingSamplerInvalidTest::BindingSamplerInvalidTest(deqp::Context& context) 11326 : NegativeTestBase(context, "binding_sampler_invalid", "Test verifies invalid binding values") 11327 { 11328 /* Nothing to be done here */ 11329 } 11330 11331 /** Set up next test case 11332 * 11333 * @param test_case_index Index of next test case 11334 * 11335 * @return false if there is no more test cases, true otherwise 11336 **/ 11337 bool BindingSamplerInvalidTest::prepareNextTestCase(glw::GLuint test_case_index) 11338 { 11339 switch (test_case_index) 11340 { 11341 case (glw::GLuint)-1: 11342 m_case = TEST_CASES_MAX; 11343 break; 11344 case NEGATIVE_VALUE: 11345 case VARIABLE_NAME: 11346 case STD140: 11347 case MISSING: 11348 m_case = (TESTCASES)test_case_index; 11349 break; 11350 default: 11351 return false; 11352 } 11353 11354 return true; 11355 } 11356 11357 /** Prepare source for given shader stage 11358 * 11359 * @param in_stage Shader stage, compute shader will use 430 11360 * @param in_use_version_400 Select if 400 or 420 should be used 11361 * @param out_source Prepared shader source instance 11362 **/ 11363 void BindingSamplerInvalidTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 11364 Utils::shaderSource& out_source) 11365 { 11366 static const GLchar* uni_goku = "layout(binding BINDING) uniform sampler2D goku;\n"; 11367 11368 static const GLchar* verification_snippet = " vec4 color = texture(goku, vec2(0,0));\n" 11369 " if (vec4(1, 0, 0, 0) != color)\n" 11370 " {\n" 11371 " result = vec4(1, 0, 0, 1);\n" 11372 " }\n"; 11373 11374 static const GLchar* compute_shader_template = 11375 "VERSION\n" 11376 "\n" 11377 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 11378 "\n" 11379 "writeonly uniform image2D uni_image;\n" 11380 "\n" 11381 "UNI_GOKU\n" 11382 "\n" 11383 "void main()\n" 11384 "{\n" 11385 " vec4 result = vec4(0, 1, 0, 1);\n" 11386 "\n" 11387 "VERIFICATION" 11388 "\n" 11389 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 11390 "}\n" 11391 "\n"; 11392 11393 static const GLchar* fragment_shader_template = "VERSION\n" 11394 "\n" 11395 "in vec4 gs_fs_result;\n" 11396 "out vec4 fs_out_result;\n" 11397 "\n" 11398 "UNI_GOKU\n" 11399 "\n" 11400 "void main()\n" 11401 "{\n" 11402 " vec4 result = vec4(0, 1, 0, 1);\n" 11403 "\n" 11404 "VERIFICATION" 11405 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 11406 " {\n" 11407 " result = vec4(1, 0, 0, 1);\n" 11408 " }\n" 11409 "\n" 11410 " fs_out_result = result;\n" 11411 "}\n" 11412 "\n"; 11413 11414 static const GLchar* geometry_shader_template = "VERSION\n" 11415 "\n" 11416 "layout(points) in;\n" 11417 "layout(triangle_strip, max_vertices = 4) out;\n" 11418 "\n" 11419 "in vec4 tes_gs_result[];\n" 11420 "out vec4 gs_fs_result;\n" 11421 "\n" 11422 "UNI_GOKU\n" 11423 "\n" 11424 "void main()\n" 11425 "{\n" 11426 " vec4 result = vec4(0, 1, 0, 1);\n" 11427 "\n" 11428 "VERIFICATION" 11429 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 11430 " {\n" 11431 " result = vec4(1, 0, 0, 1);\n" 11432 " }\n" 11433 "\n" 11434 " gs_fs_result = result;\n" 11435 " gl_Position = vec4(-1, -1, 0, 1);\n" 11436 " EmitVertex();\n" 11437 " gs_fs_result = result;\n" 11438 " gl_Position = vec4(-1, 1, 0, 1);\n" 11439 " EmitVertex();\n" 11440 " gs_fs_result = result;\n" 11441 " gl_Position = vec4(1, -1, 0, 1);\n" 11442 " EmitVertex();\n" 11443 " gs_fs_result = result;\n" 11444 " gl_Position = vec4(1, 1, 0, 1);\n" 11445 " EmitVertex();\n" 11446 "}\n" 11447 "\n"; 11448 11449 static const GLchar* tess_ctrl_shader_template = 11450 "VERSION\n" 11451 "\n" 11452 "layout(vertices = 1) out;\n" 11453 "\n" 11454 "in vec4 vs_tcs_result[];\n" 11455 "out vec4 tcs_tes_result[];\n" 11456 "\n" 11457 "UNI_GOKU\n" 11458 "\n" 11459 "void main()\n" 11460 "{\n" 11461 " vec4 result = vec4(0, 1, 0, 1);\n" 11462 "\n" 11463 "VERIFICATION" 11464 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 11465 " {\n" 11466 " result = vec4(1, 0, 0, 1);\n" 11467 " }\n" 11468 "\n" 11469 " tcs_tes_result[gl_InvocationID] = result;\n" 11470 "\n" 11471 " gl_TessLevelOuter[0] = 1.0;\n" 11472 " gl_TessLevelOuter[1] = 1.0;\n" 11473 " gl_TessLevelOuter[2] = 1.0;\n" 11474 " gl_TessLevelOuter[3] = 1.0;\n" 11475 " gl_TessLevelInner[0] = 1.0;\n" 11476 " gl_TessLevelInner[1] = 1.0;\n" 11477 "}\n" 11478 "\n"; 11479 11480 static const GLchar* tess_eval_shader_template = "VERSION\n" 11481 "\n" 11482 "layout(isolines, point_mode) in;\n" 11483 "\n" 11484 "in vec4 tcs_tes_result[];\n" 11485 "out vec4 tes_gs_result;\n" 11486 "\n" 11487 "UNI_GOKU\n" 11488 "\n" 11489 "void main()\n" 11490 "{\n" 11491 " vec4 result = vec4(0, 1, 0, 1);\n" 11492 "\n" 11493 "VERIFICATION" 11494 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 11495 " {\n" 11496 " result = vec4(1, 0, 0, 1);\n" 11497 " }\n" 11498 "\n" 11499 " tes_gs_result = result;\n" 11500 "}\n" 11501 "\n"; 11502 11503 static const GLchar* vertex_shader_template = "VERSION\n" 11504 "\n" 11505 "out vec4 vs_tcs_result;\n" 11506 "\n" 11507 "UNI_GOKU\n" 11508 "\n" 11509 "void main()\n" 11510 "{\n" 11511 " vec4 result = vec4(0, 1, 0, 1);\n" 11512 "\n" 11513 "VERIFICATION" 11514 "\n" 11515 " vs_tcs_result = result;\n" 11516 "}\n" 11517 "\n"; 11518 11519 const GLchar* shader_template = 0; 11520 11521 switch (in_stage) 11522 { 11523 case Utils::COMPUTE_SHADER: 11524 shader_template = compute_shader_template; 11525 break; 11526 case Utils::FRAGMENT_SHADER: 11527 shader_template = fragment_shader_template; 11528 break; 11529 case Utils::GEOMETRY_SHADER: 11530 shader_template = geometry_shader_template; 11531 break; 11532 case Utils::TESS_CTRL_SHADER: 11533 shader_template = tess_ctrl_shader_template; 11534 break; 11535 case Utils::TESS_EVAL_SHADER: 11536 shader_template = tess_eval_shader_template; 11537 break; 11538 case Utils::VERTEX_SHADER: 11539 shader_template = vertex_shader_template; 11540 break; 11541 default: 11542 TCU_FAIL("Invalid enum"); 11543 break; 11544 } 11545 11546 out_source.m_parts[0].m_code = shader_template; 11547 11548 size_t position = 0; 11549 11550 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 11551 out_source.m_parts[0].m_code); 11552 11553 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 11554 11555 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 11556 11557 Utils::replaceAllTokens("BINDING", getCaseString(m_case), out_source.m_parts[0].m_code); 11558 } 11559 11560 const GLchar* BindingSamplerInvalidTest::getCaseString(TESTCASES test_case) 11561 { 11562 (void)test_case; 11563 const GLchar* binding = 0; 11564 11565 switch (m_case) 11566 { 11567 case NEGATIVE_VALUE: 11568 binding = "= -1"; 11569 break; 11570 case VARIABLE_NAME: 11571 binding = "= goku"; 11572 break; 11573 case STD140: 11574 binding = "= std140"; 11575 break; 11576 case MISSING: 11577 binding = ""; 11578 break; 11579 case TEST_CASES_MAX: 11580 binding = "= 0"; 11581 break; 11582 default: 11583 TCU_FAIL("Invalid enum"); 11584 } 11585 11586 return binding; 11587 } 11588 11589 /* Constants used by BindingImagesTest */ 11590 const GLuint BindingImagesTest::m_goku_data = 0x000000ff; 11591 const GLuint BindingImagesTest::m_vegeta_data = 0x0000ff00; 11592 const GLuint BindingImagesTest::m_trunks_data = 0x00ff0000; 11593 11594 /** Constructor 11595 * 11596 * @param context Test context 11597 **/ 11598 BindingImagesTest::BindingImagesTest(deqp::Context& context) 11599 : BindingImageTest(context, "binding_images", "Test verifies binding of images") 11600 , m_goku_texture(context) 11601 , m_vegeta_texture(context) 11602 , m_trunks_texture(context) 11603 , m_goku_buffer(context) 11604 , m_vegeta_buffer(context) 11605 , m_trunks_buffer(context) 11606 { 11607 /* Nothing to be done here */ 11608 } 11609 11610 /** Set up next test case 11611 * 11612 * @param test_case_index Index of next test case 11613 * 11614 * @return false if there is no more test cases, true otherwise 11615 **/ 11616 bool BindingImagesTest::prepareNextTestCase(glw::GLuint test_case_index) 11617 { 11618 switch (test_case_index) 11619 { 11620 case (glw::GLuint)-1: 11621 case 0: 11622 m_test_case = Utils::TEX_2D; 11623 break; 11624 case 1: 11625 m_test_case = Utils::TEX_BUFFER; 11626 break; 11627 case 2: 11628 m_test_case = Utils::TEX_2D_RECT; 11629 break; 11630 case 3: 11631 m_test_case = Utils::TEX_2D_ARRAY; 11632 break; 11633 case 4: 11634 m_test_case = Utils::TEX_3D; 11635 break; 11636 case 5: 11637 m_test_case = Utils::TEX_CUBE; 11638 break; 11639 case 6: 11640 m_test_case = Utils::TEX_1D; 11641 break; 11642 case 7: 11643 m_test_case = Utils::TEX_1D_ARRAY; 11644 break; 11645 default: 11646 return false; 11647 break; 11648 } 11649 11650 m_context.getTestContext().getLog() << tcu::TestLog::Message 11651 << "Tested texture type: " << Utils::getTextureTypeName(m_test_case) 11652 << tcu::TestLog::EndMessage; 11653 11654 return true; 11655 } 11656 11657 /** Prepare source for given shader stage 11658 * 11659 * @param in_stage Shader stage, compute shader will use 430 11660 * @param in_use_version_400 Select if 400 or 420 should be used 11661 * @param out_source Prepared shader source instance 11662 **/ 11663 void BindingImagesTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 11664 Utils::shaderSource& out_source) 11665 { 11666 static const GLchar* uni_goku = "layout(binding = 1, rgba8) uniform TYPE goku;\n"; 11667 11668 static const GLchar* uni_vegeta = "layout(binding = 2, rgba8) uniform TYPE vegeta;\n"; 11669 11670 static const GLchar* uni_trunks = "layout(binding = 4, rgba8) uniform TYPE trunks;\n\n"; 11671 11672 static const GLchar* verification_snippet = " TEX_COORD_TYPE tex_coord_read = TEX_COORD_TYPE(COORDINATES);\n" 11673 " TEX_COORD_TYPE tex_coord_write = TEX_COORD_TYPE(COORDINATES);\n" 11674 " vec4 goku_color = imageLoad(goku, tex_coord_read);\n" 11675 " vec4 vegeta_color = imageLoad(vegeta, tex_coord_read);\n" 11676 " vec4 trunks_color = imageLoad(trunks, tex_coord_read);\n" 11677 "\n" 11678 " imageStore(goku, tex_coord_write, vec4(0, 1, 0, 1));\n" 11679 " imageStore(vegeta, tex_coord_write, vec4(0, 1, 0, 1));\n" 11680 " imageStore(trunks, tex_coord_write, vec4(0, 1, 0, 1));\n" 11681 "\n" 11682 " if ((vec4(1, 0, 0, 0) != goku_color) ||\n" 11683 " (vec4(0, 1, 0, 0) != vegeta_color) ||\n" 11684 " (vec4(0, 0, 1, 0) != trunks_color) )\n" 11685 " {\n" 11686 " result = goku_color;\n" 11687 " //result = vec4(1, 0, 0, 1);\n" 11688 " }\n"; 11689 11690 static const GLchar* compute_shader_template = 11691 "VERSION\n" 11692 "#extension GL_ARB_shader_image_load_store : enable\n" 11693 "\n" 11694 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 11695 "\n" 11696 "writeonly uniform image2D uni_image;\n" 11697 "\n" 11698 "UNI_GOKU\n" 11699 "UNI_VEGETA\n" 11700 "UNI_TRUNKS\n" 11701 "\n" 11702 "void main()\n" 11703 "{\n" 11704 " vec4 result = vec4(0, 1, 0, 1);\n" 11705 "\n" 11706 " if(gl_GlobalInvocationID.xy == vec2(0, 0)) {\n" 11707 "VERIFICATION" 11708 " }\n" 11709 "\n" 11710 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 11711 "}\n" 11712 "\n"; 11713 11714 static const GLchar* fragment_shader_template = "VERSION\n" 11715 "#extension GL_ARB_shader_image_load_store : enable\n" 11716 "\n" 11717 "in vec4 gs_fs_result;\n" 11718 "out vec4 fs_out_result;\n" 11719 "\n" 11720 "UNI_GOKU\n" 11721 "UNI_VEGETA\n" 11722 "UNI_TRUNKS\n" 11723 "\n" 11724 "void main()\n" 11725 "{\n" 11726 " vec4 result = vec4(0, 1, 0, 1);\n" 11727 "\n" 11728 "VERIFICATION" 11729 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 11730 " {\n" 11731 " result = vec4(1, 0, 0, 1);\n" 11732 " }\n" 11733 "\n" 11734 " fs_out_result = result;\n" 11735 "}\n" 11736 "\n"; 11737 11738 static const GLchar* geometry_shader_template = "VERSION\n" 11739 "#extension GL_ARB_shader_image_load_store : enable\n" 11740 "\n" 11741 "layout(points) in;\n" 11742 "layout(triangle_strip, max_vertices = 4) out;\n" 11743 "\n" 11744 "in vec4 tes_gs_result[];\n" 11745 "out vec4 gs_fs_result;\n" 11746 "\n" 11747 "UNI_TRUNKS\n" 11748 "UNI_GOKU\n" 11749 "UNI_VEGETA\n" 11750 "\n" 11751 "void main()\n" 11752 "{\n" 11753 " vec4 result = vec4(0, 1, 0, 1);\n" 11754 "\n" 11755 "VERIFICATION" 11756 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 11757 " {\n" 11758 " result = vec4(1, 0, 0, 1);\n" 11759 " }\n" 11760 "\n" 11761 " gs_fs_result = result;\n" 11762 " gl_Position = vec4(-1, -1, 0, 1);\n" 11763 " EmitVertex();\n" 11764 " gs_fs_result = result;\n" 11765 " gl_Position = vec4(-1, 1, 0, 1);\n" 11766 " EmitVertex();\n" 11767 " gs_fs_result = result;\n" 11768 " gl_Position = vec4(1, -1, 0, 1);\n" 11769 " EmitVertex();\n" 11770 " gs_fs_result = result;\n" 11771 " gl_Position = vec4(1, 1, 0, 1);\n" 11772 " EmitVertex();\n" 11773 "}\n" 11774 "\n"; 11775 11776 static const GLchar* tess_ctrl_shader_template = 11777 "VERSION\n" 11778 "#extension GL_ARB_shader_image_load_store : enable\n" 11779 "\n" 11780 "layout(vertices = 1) out;\n" 11781 "\n" 11782 "in vec4 vs_tcs_result[];\n" 11783 "out vec4 tcs_tes_result[];\n" 11784 "\n" 11785 "UNI_VEGETA\n" 11786 "UNI_TRUNKS\n" 11787 "UNI_GOKU\n" 11788 "\n" 11789 "void main()\n" 11790 "{\n" 11791 " vec4 result = vec4(0, 1, 0, 1);\n" 11792 "\n" 11793 "VERIFICATION" 11794 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 11795 " {\n" 11796 " result = vec4(1, 0, 0, 1);\n" 11797 " }\n" 11798 "\n" 11799 " tcs_tes_result[gl_InvocationID] = result;\n" 11800 "\n" 11801 " gl_TessLevelOuter[0] = 1.0;\n" 11802 " gl_TessLevelOuter[1] = 1.0;\n" 11803 " gl_TessLevelOuter[2] = 1.0;\n" 11804 " gl_TessLevelOuter[3] = 1.0;\n" 11805 " gl_TessLevelInner[0] = 1.0;\n" 11806 " gl_TessLevelInner[1] = 1.0;\n" 11807 "}\n" 11808 "\n"; 11809 11810 static const GLchar* tess_eval_shader_template = "VERSION\n" 11811 "#extension GL_ARB_shader_image_load_store : enable\n" 11812 "\n" 11813 "layout(isolines, point_mode) in;\n" 11814 "\n" 11815 "in vec4 tcs_tes_result[];\n" 11816 "out vec4 tes_gs_result;\n" 11817 "\n" 11818 "UNI_GOKU\n" 11819 "UNI_TRUNKS\n" 11820 "UNI_VEGETA\n" 11821 "\n" 11822 "void main()\n" 11823 "{\n" 11824 " vec4 result = vec4(0, 1, 0, 1);\n" 11825 "\n" 11826 "VERIFICATION" 11827 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 11828 " {\n" 11829 " result = vec4(1, 0, 0, 1);\n" 11830 " }\n" 11831 "\n" 11832 " tes_gs_result = result;\n" 11833 "}\n" 11834 "\n"; 11835 11836 static const GLchar* vertex_shader_template = "VERSION\n" 11837 "#extension GL_ARB_shader_image_load_store : enable\n" 11838 "\n" 11839 "out vec4 vs_tcs_result;\n" 11840 "\n" 11841 "UNI_TRUNKS\n" 11842 "UNI_VEGETA\n" 11843 "UNI_GOKU\n" 11844 "\n" 11845 "void main()\n" 11846 "{\n" 11847 " vec4 result = vec4(0, 1, 0, 1);\n" 11848 "\n" 11849 "VERIFICATION" 11850 "\n" 11851 " vs_tcs_result = result;\n" 11852 "}\n" 11853 "\n"; 11854 11855 const GLchar* coordinates_read = 0; 11856 const GLchar* coordinates_write = 0; 11857 const GLchar* image_type = Utils::getImageType(m_test_case); 11858 GLuint n_coordinates = Utils::getNumberOfCoordinates(m_test_case); 11859 const GLchar* shader_template = 0; 11860 const GLchar* tex_coord_type = Utils::getTypeName(Utils::INT, 1 /* n_columns */, n_coordinates); 11861 11862 switch (in_stage) 11863 { 11864 case Utils::COMPUTE_SHADER: 11865 shader_template = compute_shader_template; 11866 break; 11867 case Utils::FRAGMENT_SHADER: 11868 shader_template = fragment_shader_template; 11869 break; 11870 case Utils::GEOMETRY_SHADER: 11871 shader_template = geometry_shader_template; 11872 break; 11873 case Utils::TESS_CTRL_SHADER: 11874 shader_template = tess_ctrl_shader_template; 11875 break; 11876 case Utils::TESS_EVAL_SHADER: 11877 shader_template = tess_eval_shader_template; 11878 break; 11879 case Utils::VERTEX_SHADER: 11880 shader_template = vertex_shader_template; 11881 break; 11882 default: 11883 TCU_FAIL("Invalid enum"); 11884 break; 11885 } 11886 11887 switch (n_coordinates) 11888 { 11889 case 1: 11890 coordinates_read = "1"; 11891 coordinates_write = "0"; 11892 break; 11893 case 2: 11894 coordinates_read = "1, 0"; 11895 coordinates_write = "0, 0"; 11896 break; 11897 case 3: 11898 coordinates_read = "1, 0, 0"; 11899 coordinates_write = "0, 0, 0"; 11900 break; 11901 case 4: 11902 coordinates_read = "1, 0, 0, 0"; 11903 coordinates_write = "0, 0, 0, 0"; 11904 break; 11905 } 11906 11907 out_source.m_parts[0].m_code = shader_template; 11908 11909 size_t position = 0; 11910 11911 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 11912 out_source.m_parts[0].m_code); 11913 11914 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 11915 11916 position -= strlen(verification_snippet); 11917 11918 Utils::replaceToken("COORDINATES", position, coordinates_read, out_source.m_parts[0].m_code); 11919 11920 Utils::replaceToken("COORDINATES", position, coordinates_write, out_source.m_parts[0].m_code); 11921 11922 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 11923 11924 Utils::replaceAllTokens("UNI_VEGETA", uni_vegeta, out_source.m_parts[0].m_code); 11925 11926 Utils::replaceAllTokens("UNI_TRUNKS", uni_trunks, out_source.m_parts[0].m_code); 11927 11928 Utils::replaceAllTokens("TEX_COORD_TYPE", tex_coord_type, out_source.m_parts[0].m_code); 11929 11930 Utils::replaceAllTokens("TYPE", image_type, out_source.m_parts[0].m_code); 11931 } 11932 11933 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 11934 * 11935 * @param program Current program 11936 **/ 11937 void BindingImagesTest::prepareUniforms(Utils::program& program) 11938 { 11939 (void)program; 11940 prepareBuffer(m_goku_buffer, m_goku_data); 11941 prepareBuffer(m_vegeta_buffer, m_vegeta_data); 11942 prepareBuffer(m_trunks_buffer, m_trunks_data); 11943 11944 prepareTexture(m_goku_texture, m_goku_buffer, m_test_case, m_goku_data, 1); 11945 prepareTexture(m_vegeta_texture, m_vegeta_buffer, m_test_case, m_vegeta_data, 2); 11946 prepareTexture(m_trunks_texture, m_trunks_buffer, m_test_case, m_trunks_data, 4); 11947 } 11948 11949 /** Overwrite of releaseResource method, release extra buffers and textures 11950 * 11951 * @param ignored 11952 **/ 11953 void BindingImagesTest::releaseResource() 11954 { 11955 m_goku_texture.release(); 11956 m_vegeta_texture.release(); 11957 m_trunks_texture.release(); 11958 if (m_test_case != Utils::TEX_BUFFER) 11959 { 11960 m_goku_buffer.release(); 11961 m_vegeta_buffer.release(); 11962 m_trunks_buffer.release(); 11963 } 11964 } 11965 11966 /** Verify that all images have green texel at [0,0,0,0] 11967 * 11968 * @return true texel is green, false otherwise 11969 **/ 11970 bool BindingImagesTest::verifyAdditionalResults() const 11971 { 11972 if (Utils::TEX_BUFFER != m_test_case) 11973 { 11974 return (verifyTexture(m_goku_texture) && verifyTexture(m_vegeta_texture) && verifyTexture(m_trunks_texture)); 11975 } 11976 else 11977 { 11978 return (verifyBuffer(m_goku_buffer) && verifyBuffer(m_vegeta_buffer) && verifyBuffer(m_trunks_buffer)); 11979 } 11980 } 11981 11982 /** Constructor 11983 * 11984 * @param context Test context 11985 **/ 11986 BindingImageSingleTest::BindingImageSingleTest(deqp::Context& context) 11987 : BindingImageTest(context, "binding_image_single", "Test verifies single binding of image used in multiple stages") 11988 , m_goku_texture(context) 11989 { 11990 /* Nothing to be done here */ 11991 } 11992 11993 /** Set up next test case 11994 * 11995 * @param test_case_index Index of next test case 11996 * 11997 * @return false if there is no more test cases, true otherwise 11998 **/ 11999 bool BindingImageSingleTest::prepareNextTestCase(glw::GLuint test_case_index) 12000 { 12001 switch (test_case_index) 12002 { 12003 case (glw::GLuint)-1: 12004 case 0: 12005 m_test_stage = Utils::VERTEX_SHADER; 12006 break; 12007 case 1: 12008 m_test_stage = Utils::TESS_CTRL_SHADER; 12009 break; 12010 case 2: 12011 m_test_stage = Utils::TESS_EVAL_SHADER; 12012 break; 12013 case 3: 12014 m_test_stage = Utils::GEOMETRY_SHADER; 12015 break; 12016 case 4: 12017 m_test_stage = Utils::FRAGMENT_SHADER; 12018 break; 12019 default: 12020 return false; 12021 break; 12022 } 12023 12024 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Tested stage: " 12025 << Utils::getShaderStageName((Utils::SHADER_STAGES)m_test_stage) 12026 << tcu::TestLog::EndMessage; 12027 12028 return true; 12029 } 12030 12031 /** Prepare source for given shader stage 12032 * 12033 * @param in_stage Shader stage, compute shader will use 430 12034 * @param in_use_version_400 Select if 400 or 420 should be used 12035 * @param out_source Prepared shader source instance 12036 **/ 12037 void BindingImageSingleTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 12038 Utils::shaderSource& out_source) 12039 { 12040 static const GLchar* uni_goku_with_binding = "layout(binding = 2, rgba8) uniform image2D goku;\n"; 12041 12042 static const GLchar* uni_goku_no_binding = "layout(rgba8) uniform image2D goku;\n"; 12043 12044 static const GLchar* verification_snippet = " vec4 goku_color = imageLoad(goku, ivec2(0,1));\n" 12045 "\n" 12046 " imageStore(goku, ivec2(0,0), vec4(0, 1, 0, 1));\n" 12047 "\n" 12048 " if (vec4(1, 0, 0, 0) != goku_color)\n" 12049 " {\n" 12050 " result = vec4(1, 0, 0, 1);\n" 12051 " }\n"; 12052 12053 static const GLchar* compute_shader_template = 12054 "VERSION\n" 12055 "#extension GL_ARB_shader_image_load_store : enable\n" 12056 "\n" 12057 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 12058 "\n" 12059 "writeonly uniform image2D uni_image;\n" 12060 "\n" 12061 "UNI_GOKU\n" 12062 "\n" 12063 "void main()\n" 12064 "{\n" 12065 " vec4 result = vec4(0, 1, 0, 1);\n" 12066 "\n" 12067 "VERIFICATION" 12068 "\n" 12069 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 12070 "}\n" 12071 "\n"; 12072 12073 static const GLchar* fragment_shader_template = "VERSION\n" 12074 "#extension GL_ARB_shader_image_load_store : enable\n" 12075 "\n" 12076 "in vec4 gs_fs_result;\n" 12077 "out vec4 fs_out_result;\n" 12078 "\n" 12079 "UNI_GOKU\n" 12080 "\n" 12081 "void main()\n" 12082 "{\n" 12083 " vec4 result = vec4(0, 1, 0, 1);\n" 12084 "\n" 12085 "VERIFICATION" 12086 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 12087 " {\n" 12088 " result = vec4(1, 0, 0, 1);\n" 12089 " }\n" 12090 "\n" 12091 " fs_out_result = result;\n" 12092 "}\n" 12093 "\n"; 12094 12095 static const GLchar* geometry_shader_template = "VERSION\n" 12096 "#extension GL_ARB_shader_image_load_store : enable\n" 12097 "\n" 12098 "layout(points) in;\n" 12099 "layout(triangle_strip, max_vertices = 4) out;\n" 12100 "\n" 12101 "in vec4 tes_gs_result[];\n" 12102 "out vec4 gs_fs_result;\n" 12103 "\n" 12104 "UNI_GOKU\n" 12105 "\n" 12106 "void main()\n" 12107 "{\n" 12108 " vec4 result = vec4(0, 1, 0, 1);\n" 12109 "\n" 12110 "VERIFICATION" 12111 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 12112 " {\n" 12113 " result = vec4(1, 0, 0, 1);\n" 12114 " }\n" 12115 "\n" 12116 " gs_fs_result = result;\n" 12117 " gl_Position = vec4(-1, -1, 0, 1);\n" 12118 " EmitVertex();\n" 12119 " gs_fs_result = result;\n" 12120 " gl_Position = vec4(-1, 1, 0, 1);\n" 12121 " EmitVertex();\n" 12122 " gs_fs_result = result;\n" 12123 " gl_Position = vec4(1, -1, 0, 1);\n" 12124 " EmitVertex();\n" 12125 " gs_fs_result = result;\n" 12126 " gl_Position = vec4(1, 1, 0, 1);\n" 12127 " EmitVertex();\n" 12128 "}\n" 12129 "\n"; 12130 12131 static const GLchar* tess_ctrl_shader_template = 12132 "VERSION\n" 12133 "#extension GL_ARB_shader_image_load_store : enable\n" 12134 "\n" 12135 "layout(vertices = 1) out;\n" 12136 "\n" 12137 "in vec4 vs_tcs_result[];\n" 12138 "out vec4 tcs_tes_result[];\n" 12139 "\n" 12140 "UNI_GOKU\n" 12141 "\n" 12142 "void main()\n" 12143 "{\n" 12144 " vec4 result = vec4(0, 1, 0, 1);\n" 12145 "\n" 12146 "VERIFICATION" 12147 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 12148 " {\n" 12149 " result = vec4(1, 0, 0, 1);\n" 12150 " }\n" 12151 "\n" 12152 " tcs_tes_result[gl_InvocationID] = result;\n" 12153 "\n" 12154 " gl_TessLevelOuter[0] = 1.0;\n" 12155 " gl_TessLevelOuter[1] = 1.0;\n" 12156 " gl_TessLevelOuter[2] = 1.0;\n" 12157 " gl_TessLevelOuter[3] = 1.0;\n" 12158 " gl_TessLevelInner[0] = 1.0;\n" 12159 " gl_TessLevelInner[1] = 1.0;\n" 12160 "}\n" 12161 "\n"; 12162 12163 static const GLchar* tess_eval_shader_template = "VERSION\n" 12164 "#extension GL_ARB_shader_image_load_store : enable\n" 12165 "\n" 12166 "layout(isolines, point_mode) in;\n" 12167 "\n" 12168 "in vec4 tcs_tes_result[];\n" 12169 "out vec4 tes_gs_result;\n" 12170 "\n" 12171 "UNI_GOKU\n" 12172 "\n" 12173 "void main()\n" 12174 "{\n" 12175 " vec4 result = vec4(0, 1, 0, 1);\n" 12176 "\n" 12177 "VERIFICATION" 12178 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 12179 " {\n" 12180 " result = vec4(1, 0, 0, 1);\n" 12181 " }\n" 12182 "\n" 12183 " tes_gs_result = result;\n" 12184 "}\n" 12185 "\n"; 12186 12187 static const GLchar* vertex_shader_template = "VERSION\n" 12188 "#extension GL_ARB_shader_image_load_store : enable\n" 12189 "\n" 12190 "out vec4 vs_tcs_result;\n" 12191 "\n" 12192 "UNI_GOKU\n" 12193 "\n" 12194 "void main()\n" 12195 "{\n" 12196 " vec4 result = vec4(0, 1, 0, 1);\n" 12197 "\n" 12198 "VERIFICATION" 12199 "\n" 12200 " vs_tcs_result = result;\n" 12201 "}\n" 12202 "\n"; 12203 12204 const GLchar* shader_template = 0; 12205 const GLchar* uniform_definition = uni_goku_no_binding; 12206 12207 switch (in_stage) 12208 { 12209 case Utils::COMPUTE_SHADER: 12210 shader_template = compute_shader_template; 12211 uniform_definition = uni_goku_with_binding; 12212 break; 12213 case Utils::FRAGMENT_SHADER: 12214 shader_template = fragment_shader_template; 12215 break; 12216 case Utils::GEOMETRY_SHADER: 12217 shader_template = geometry_shader_template; 12218 break; 12219 case Utils::TESS_CTRL_SHADER: 12220 shader_template = tess_ctrl_shader_template; 12221 break; 12222 case Utils::TESS_EVAL_SHADER: 12223 shader_template = tess_eval_shader_template; 12224 break; 12225 case Utils::VERTEX_SHADER: 12226 shader_template = vertex_shader_template; 12227 break; 12228 default: 12229 TCU_FAIL("Invalid enum"); 12230 break; 12231 } 12232 12233 if (in_stage == m_test_stage) 12234 { 12235 uniform_definition = uni_goku_with_binding; 12236 } 12237 12238 out_source.m_parts[0].m_code = shader_template; 12239 12240 size_t position = 0; 12241 12242 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 12243 out_source.m_parts[0].m_code); 12244 12245 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 12246 12247 Utils::replaceAllTokens("UNI_GOKU", uniform_definition, out_source.m_parts[0].m_code); 12248 } 12249 12250 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 12251 * 12252 * @param program Current program 12253 **/ 12254 void BindingImageSingleTest::prepareUniforms(Utils::program& program) 12255 { 12256 (void)program; 12257 static const GLuint goku_data = 0x000000ff; 12258 12259 prepareTexture(m_goku_texture, Utils::buffer(m_context), Utils::TEX_2D, goku_data, 2 /* unit */); 12260 } 12261 12262 /** Overwrite of releaseResource method, release extra texture 12263 * 12264 * @param ignored 12265 **/ 12266 void BindingImageSingleTest::releaseResource() 12267 { 12268 m_goku_texture.release(); 12269 } 12270 12271 /** Verify that all images have green texel at [0,0,0,0] 12272 * 12273 * @return true texel is green, false otherwise 12274 **/ 12275 bool BindingImageSingleTest::verifyAdditionalResults() const 12276 { 12277 return verifyTexture(m_goku_texture); 12278 } 12279 12280 /** Constructor 12281 * 12282 * @param context Test context 12283 **/ 12284 BindingImageArrayTest::BindingImageArrayTest(deqp::Context& context) 12285 : BindingImageTest(context, "binding_image_array", "Test verifies binding of image array") 12286 , m_goku_00_texture(context) 12287 , m_goku_01_texture(context) 12288 , m_goku_02_texture(context) 12289 , m_goku_03_texture(context) 12290 , m_goku_04_texture(context) 12291 , m_goku_05_texture(context) 12292 , m_goku_06_texture(context) 12293 { 12294 /* Nothing to be done here */ 12295 } 12296 12297 /** Prepare source for given shader stage 12298 * 12299 * @param in_stage Shader stage, compute shader will use 430 12300 * @param in_use_version_400 Select if 400 or 420 should be used 12301 * @param out_source Prepared shader source instance 12302 **/ 12303 void BindingImageArrayTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 12304 Utils::shaderSource& out_source) 12305 { 12306 static const GLchar* uni_goku = "layout(binding = 1, rgba8) uniform image2D goku[7];\n"; 12307 12308 static const GLchar* verification_snippet = " vec4 color[7];\n" 12309 "\n" 12310 " for (uint i = 0u; i < 7; ++i)\n" 12311 " {\n" 12312 " color[i] = imageLoad(goku[i], ivec2(0,0));\n" 12313 " }\n" 12314 "\n" 12315 " if ((vec4(0, 0, 0, 0) != color[0]) ||\n" 12316 " (vec4(0, 0, 0, 1) != color[1]) ||\n" 12317 " (vec4(0, 0, 1, 0) != color[2]) ||\n" 12318 " (vec4(0, 0, 1, 1) != color[3]) ||\n" 12319 " (vec4(0, 1, 0, 0) != color[4]) ||\n" 12320 " (vec4(0, 1, 0, 1) != color[5]) ||\n" 12321 " (vec4(0, 1, 1, 0) != color[6]) )\n" 12322 " {\n" 12323 " result = vec4(1, 0, 0, 1);\n" 12324 " }\n"; 12325 12326 static const GLchar* compute_shader_template = 12327 "VERSION\n" 12328 "#extension GL_ARB_shader_image_load_store : enable\n" 12329 "\n" 12330 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 12331 "\n" 12332 "writeonly uniform image2D uni_image;\n" 12333 "\n" 12334 "UNI_GOKU\n" 12335 "\n" 12336 "void main()\n" 12337 "{\n" 12338 " vec4 result = vec4(0, 1, 0, 1);\n" 12339 "\n" 12340 "VERIFICATION" 12341 "\n" 12342 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 12343 "}\n" 12344 "\n"; 12345 12346 static const GLchar* fragment_shader_template = "VERSION\n" 12347 "#extension GL_ARB_shader_image_load_store : enable\n" 12348 "\n" 12349 "in vec4 gs_fs_result;\n" 12350 "out vec4 fs_out_result;\n" 12351 "\n" 12352 "UNI_GOKU\n" 12353 "\n" 12354 "void main()\n" 12355 "{\n" 12356 " vec4 result = vec4(0, 1, 0, 1);\n" 12357 "\n" 12358 "VERIFICATION" 12359 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 12360 " {\n" 12361 " result = vec4(1, 0, 0, 1);\n" 12362 " }\n" 12363 "\n" 12364 " fs_out_result = result;\n" 12365 "}\n" 12366 "\n"; 12367 12368 static const GLchar* geometry_shader_template = "VERSION\n" 12369 "#extension GL_ARB_shader_image_load_store : enable\n" 12370 "\n" 12371 "layout(points) in;\n" 12372 "layout(triangle_strip, max_vertices = 4) out;\n" 12373 "\n" 12374 "in vec4 tes_gs_result[];\n" 12375 "out vec4 gs_fs_result;\n" 12376 "\n" 12377 "UNI_GOKU\n" 12378 "\n" 12379 "void main()\n" 12380 "{\n" 12381 " vec4 result = vec4(0, 1, 0, 1);\n" 12382 "\n" 12383 "VERIFICATION" 12384 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 12385 " {\n" 12386 " result = vec4(1, 0, 0, 1);\n" 12387 " }\n" 12388 "\n" 12389 " gs_fs_result = result;\n" 12390 " gl_Position = vec4(-1, -1, 0, 1);\n" 12391 " EmitVertex();\n" 12392 " gs_fs_result = result;\n" 12393 " gl_Position = vec4(-1, 1, 0, 1);\n" 12394 " EmitVertex();\n" 12395 " gs_fs_result = result;\n" 12396 " gl_Position = vec4(1, -1, 0, 1);\n" 12397 " EmitVertex();\n" 12398 " gs_fs_result = result;\n" 12399 " gl_Position = vec4(1, 1, 0, 1);\n" 12400 " EmitVertex();\n" 12401 "}\n" 12402 "\n"; 12403 12404 static const GLchar* tess_ctrl_shader_template = 12405 "VERSION\n" 12406 "#extension GL_ARB_shader_image_load_store : enable\n" 12407 "\n" 12408 "layout(vertices = 1) out;\n" 12409 "\n" 12410 "in vec4 vs_tcs_result[];\n" 12411 "out vec4 tcs_tes_result[];\n" 12412 "\n" 12413 "UNI_GOKU\n" 12414 "\n" 12415 "void main()\n" 12416 "{\n" 12417 " vec4 result = vec4(0, 1, 0, 1);\n" 12418 "\n" 12419 "VERIFICATION" 12420 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 12421 " {\n" 12422 " result = vec4(1, 0, 0, 1);\n" 12423 " }\n" 12424 "\n" 12425 " tcs_tes_result[gl_InvocationID] = result;\n" 12426 "\n" 12427 " gl_TessLevelOuter[0] = 1.0;\n" 12428 " gl_TessLevelOuter[1] = 1.0;\n" 12429 " gl_TessLevelOuter[2] = 1.0;\n" 12430 " gl_TessLevelOuter[3] = 1.0;\n" 12431 " gl_TessLevelInner[0] = 1.0;\n" 12432 " gl_TessLevelInner[1] = 1.0;\n" 12433 "}\n" 12434 "\n"; 12435 12436 static const GLchar* tess_eval_shader_template = "VERSION\n" 12437 "#extension GL_ARB_shader_image_load_store : enable\n" 12438 "\n" 12439 "layout(isolines, point_mode) in;\n" 12440 "\n" 12441 "in vec4 tcs_tes_result[];\n" 12442 "out vec4 tes_gs_result;\n" 12443 "\n" 12444 "UNI_GOKU\n" 12445 "\n" 12446 "void main()\n" 12447 "{\n" 12448 " vec4 result = vec4(0, 1, 0, 1);\n" 12449 "\n" 12450 "VERIFICATION" 12451 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 12452 " {\n" 12453 " result = vec4(1, 0, 0, 1);\n" 12454 " }\n" 12455 "\n" 12456 " tes_gs_result = result;\n" 12457 "}\n" 12458 "\n"; 12459 12460 static const GLchar* vertex_shader_template = "VERSION\n" 12461 "#extension GL_ARB_shader_image_load_store : enable\n" 12462 "\n" 12463 "out vec4 vs_tcs_result;\n" 12464 "\n" 12465 "UNI_GOKU\n" 12466 "\n" 12467 "void main()\n" 12468 "{\n" 12469 " vec4 result = vec4(0, 1, 0, 1);\n" 12470 "\n" 12471 "VERIFICATION" 12472 "\n" 12473 " vs_tcs_result = result;\n" 12474 "}\n" 12475 "\n"; 12476 12477 const GLchar* shader_template = 0; 12478 12479 switch (in_stage) 12480 { 12481 case Utils::COMPUTE_SHADER: 12482 shader_template = compute_shader_template; 12483 break; 12484 case Utils::FRAGMENT_SHADER: 12485 shader_template = fragment_shader_template; 12486 break; 12487 case Utils::GEOMETRY_SHADER: 12488 shader_template = geometry_shader_template; 12489 break; 12490 case Utils::TESS_CTRL_SHADER: 12491 shader_template = tess_ctrl_shader_template; 12492 break; 12493 case Utils::TESS_EVAL_SHADER: 12494 shader_template = tess_eval_shader_template; 12495 break; 12496 case Utils::VERTEX_SHADER: 12497 shader_template = vertex_shader_template; 12498 break; 12499 default: 12500 TCU_FAIL("Invalid enum"); 12501 break; 12502 } 12503 12504 out_source.m_parts[0].m_code = shader_template; 12505 12506 size_t position = 0; 12507 12508 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 12509 out_source.m_parts[0].m_code); 12510 12511 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 12512 12513 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 12514 } 12515 12516 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 12517 * 12518 * @param program Current program 12519 **/ 12520 void BindingImageArrayTest::prepareUniforms(Utils::program& program) 12521 { 12522 static const GLuint goku_data[7] = { 12523 0x00000000, 0xff000000, 0x00ff0000, 0xffff0000, 0x0000ff00, 0xff00ff00, 0x00ffff00, 12524 }; 12525 12526 Utils::texture* textures[7] = { 12527 &m_goku_00_texture, &m_goku_01_texture, &m_goku_02_texture, &m_goku_03_texture, 12528 &m_goku_04_texture, &m_goku_05_texture, &m_goku_06_texture, 12529 }; 12530 12531 for (GLuint i = 0; i < 7; ++i) 12532 { 12533 GLint expected_binding = i + 1; 12534 12535 checkBinding(program, i, expected_binding); 12536 12537 prepareTexture(*textures[i], Utils::buffer(m_context), Utils::TEX_2D, goku_data[i], expected_binding); 12538 } 12539 } 12540 12541 /** Overwrite of releaseResource method, release extra textures 12542 * 12543 * @param ignored 12544 **/ 12545 void BindingImageArrayTest::releaseResource() 12546 { 12547 Utils::texture* textures[7] = { 12548 &m_goku_00_texture, &m_goku_01_texture, &m_goku_02_texture, &m_goku_03_texture, 12549 &m_goku_04_texture, &m_goku_05_texture, &m_goku_06_texture, 12550 }; 12551 12552 for (GLuint i = 0; i < 7; ++i) 12553 { 12554 textures[i]->release(); 12555 } 12556 } 12557 12558 /** Verifies that API reports correct uniform binding 12559 * 12560 * @param program Program 12561 * @param index Index of array element 12562 * @param expected_binding Expected binding 12563 **/ 12564 void BindingImageArrayTest::checkBinding(Utils::program& program, GLuint index, GLint expected_binding) 12565 { 12566 if (false == Utils::checkUniformArrayBinding(program, "goku", index, expected_binding)) 12567 { 12568 TCU_FAIL("Wrong binding reported by API"); 12569 } 12570 } 12571 12572 /** Constructor 12573 * 12574 * @param context Test context 12575 **/ 12576 BindingImageDefaultTest::BindingImageDefaultTest(deqp::Context& context) 12577 : APITestBase(context, "binding_image_default", "Test verifies default image binding") 12578 { 12579 /* Nothing to be done here */ 12580 } 12581 12582 /** Execute API call and verifies results 12583 * 12584 * @return true when results are positive, false otherwise 12585 **/ 12586 bool BindingImageDefaultTest::checkResults(Utils::program& program) 12587 { 12588 return Utils::checkUniformBinding(program, "goku", 0 /* expected_binding */); 12589 } 12590 12591 /** Prepare source for given shader stage 12592 * 12593 * @param in_stage Shader stage, compute shader will use 430 12594 * @param in_use_version_400 Select if 400 or 420 should be used 12595 * @param out_source Prepared shader source instance 12596 **/ 12597 void BindingImageDefaultTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 12598 Utils::shaderSource& out_source) 12599 { 12600 static const GLchar* uni_goku = "layout(rgba8) uniform image2D goku;\n"; 12601 12602 static const GLchar* verification_snippet = " vec4 goku_color = imageLoad(goku, ivec2(0,0));\n" 12603 "\n" 12604 " if (vec4(1, 0, 0, 0) != goku_color)\n" 12605 " {\n" 12606 " result = vec4(1, 0, 0, 1);\n" 12607 " }\n"; 12608 12609 static const GLchar* compute_shader_template = 12610 "VERSION\n" 12611 "#extension GL_ARB_shader_image_load_store : enable\n" 12612 "\n" 12613 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 12614 "\n" 12615 "writeonly uniform image2D uni_image;\n" 12616 "\n" 12617 "UNI_GOKU\n" 12618 "\n" 12619 "void main()\n" 12620 "{\n" 12621 " vec4 result = vec4(0, 1, 0, 1);\n" 12622 "\n" 12623 "VERIFICATION" 12624 "\n" 12625 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 12626 "}\n" 12627 "\n"; 12628 12629 static const GLchar* fragment_shader_template = "VERSION\n" 12630 "#extension GL_ARB_shader_image_load_store : enable\n" 12631 "\n" 12632 "in vec4 gs_fs_result;\n" 12633 "out vec4 fs_out_result;\n" 12634 "\n" 12635 "UNI_GOKU\n" 12636 "\n" 12637 "void main()\n" 12638 "{\n" 12639 " vec4 result = vec4(0, 1, 0, 1);\n" 12640 "\n" 12641 "VERIFICATION" 12642 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 12643 " {\n" 12644 " result = vec4(1, 0, 0, 1);\n" 12645 " }\n" 12646 "\n" 12647 " fs_out_result = result;\n" 12648 "}\n" 12649 "\n"; 12650 12651 static const GLchar* geometry_shader_template = "VERSION\n" 12652 "#extension GL_ARB_shader_image_load_store : enable\n" 12653 "\n" 12654 "layout(points) in;\n" 12655 "layout(triangle_strip, max_vertices = 4) out;\n" 12656 "\n" 12657 "in vec4 tes_gs_result[];\n" 12658 "out vec4 gs_fs_result;\n" 12659 "\n" 12660 "UNI_GOKU\n" 12661 "\n" 12662 "void main()\n" 12663 "{\n" 12664 " vec4 result = vec4(0, 1, 0, 1);\n" 12665 "\n" 12666 "VERIFICATION" 12667 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 12668 " {\n" 12669 " result = vec4(1, 0, 0, 1);\n" 12670 " }\n" 12671 "\n" 12672 " gs_fs_result = result;\n" 12673 " gl_Position = vec4(-1, -1, 0, 1);\n" 12674 " EmitVertex();\n" 12675 " gs_fs_result = result;\n" 12676 " gl_Position = vec4(-1, 1, 0, 1);\n" 12677 " EmitVertex();\n" 12678 " gs_fs_result = result;\n" 12679 " gl_Position = vec4(1, -1, 0, 1);\n" 12680 " EmitVertex();\n" 12681 " gs_fs_result = result;\n" 12682 " gl_Position = vec4(1, 1, 0, 1);\n" 12683 " EmitVertex();\n" 12684 "}\n" 12685 "\n"; 12686 12687 static const GLchar* tess_ctrl_shader_template = 12688 "VERSION\n" 12689 "#extension GL_ARB_shader_image_load_store : enable\n" 12690 "\n" 12691 "layout(vertices = 1) out;\n" 12692 "\n" 12693 "in vec4 vs_tcs_result[];\n" 12694 "out vec4 tcs_tes_result[];\n" 12695 "\n" 12696 "UNI_GOKU\n" 12697 "\n" 12698 "void main()\n" 12699 "{\n" 12700 " vec4 result = vec4(0, 1, 0, 1);\n" 12701 "\n" 12702 "VERIFICATION" 12703 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 12704 " {\n" 12705 " result = vec4(1, 0, 0, 1);\n" 12706 " }\n" 12707 "\n" 12708 " tcs_tes_result[gl_InvocationID] = result;\n" 12709 "\n" 12710 " gl_TessLevelOuter[0] = 1.0;\n" 12711 " gl_TessLevelOuter[1] = 1.0;\n" 12712 " gl_TessLevelOuter[2] = 1.0;\n" 12713 " gl_TessLevelOuter[3] = 1.0;\n" 12714 " gl_TessLevelInner[0] = 1.0;\n" 12715 " gl_TessLevelInner[1] = 1.0;\n" 12716 "}\n" 12717 "\n"; 12718 12719 static const GLchar* tess_eval_shader_template = "VERSION\n" 12720 "#extension GL_ARB_shader_image_load_store : enable\n" 12721 "\n" 12722 "layout(isolines, point_mode) in;\n" 12723 "\n" 12724 "in vec4 tcs_tes_result[];\n" 12725 "out vec4 tes_gs_result;\n" 12726 "\n" 12727 "UNI_GOKU\n" 12728 "\n" 12729 "void main()\n" 12730 "{\n" 12731 " vec4 result = vec4(0, 1, 0, 1);\n" 12732 "\n" 12733 "VERIFICATION" 12734 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 12735 " {\n" 12736 " result = vec4(1, 0, 0, 1);\n" 12737 " }\n" 12738 "\n" 12739 " tes_gs_result = result;\n" 12740 "}\n" 12741 "\n"; 12742 12743 static const GLchar* vertex_shader_template = "VERSION\n" 12744 "#extension GL_ARB_shader_image_load_store : enable\n" 12745 "\n" 12746 "out vec4 vs_tcs_result;\n" 12747 "\n" 12748 "UNI_GOKU\n" 12749 "\n" 12750 "void main()\n" 12751 "{\n" 12752 " vec4 result = vec4(0, 1, 0, 1);\n" 12753 "\n" 12754 "VERIFICATION" 12755 "\n" 12756 " vs_tcs_result = result;\n" 12757 "}\n" 12758 "\n"; 12759 12760 const GLchar* shader_template = 0; 12761 12762 switch (in_stage) 12763 { 12764 case Utils::COMPUTE_SHADER: 12765 shader_template = compute_shader_template; 12766 break; 12767 case Utils::FRAGMENT_SHADER: 12768 shader_template = fragment_shader_template; 12769 break; 12770 case Utils::GEOMETRY_SHADER: 12771 shader_template = geometry_shader_template; 12772 break; 12773 case Utils::TESS_CTRL_SHADER: 12774 shader_template = tess_ctrl_shader_template; 12775 break; 12776 case Utils::TESS_EVAL_SHADER: 12777 shader_template = tess_eval_shader_template; 12778 break; 12779 case Utils::VERTEX_SHADER: 12780 shader_template = vertex_shader_template; 12781 break; 12782 default: 12783 TCU_FAIL("Invalid enum"); 12784 break; 12785 } 12786 12787 out_source.m_parts[0].m_code = shader_template; 12788 12789 size_t position = 0; 12790 12791 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 12792 out_source.m_parts[0].m_code); 12793 12794 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 12795 12796 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 12797 } 12798 12799 /** Constructor 12800 * 12801 * @param context Test context 12802 **/ 12803 BindingImageAPIOverrideTest::BindingImageAPIOverrideTest(deqp::Context& context) 12804 : BindingImageTest(context, "binding_image_api_override", "Verifies that API can override image binding") 12805 , m_goku_texture(context) 12806 { 12807 /* Nothing to be done here */ 12808 } 12809 12810 /** Prepare source for given shader stage 12811 * 12812 * @param in_stage Shader stage, compute shader will use 430 12813 * @param in_use_version_400 Select if 400 or 420 should be used 12814 * @param out_source Prepared shader source instance 12815 **/ 12816 void BindingImageAPIOverrideTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 12817 Utils::shaderSource& out_source) 12818 { 12819 static const GLchar* uni_goku = "layout(binding = 3, rgba8) uniform image2D goku;\n"; 12820 12821 static const GLchar* verification_snippet = " vec4 goku_color = imageLoad(goku, ivec2(0,0));\n" 12822 "\n" 12823 " if (vec4(1, 0, 0, 0) != goku_color)\n" 12824 " {\n" 12825 " result = vec4(1, 0, 0, 1);\n" 12826 " }\n"; 12827 12828 static const GLchar* compute_shader_template = 12829 "VERSION\n" 12830 "#extension GL_ARB_shader_image_load_store : enable\n" 12831 "\n" 12832 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 12833 "\n" 12834 "writeonly uniform image2D uni_image;\n" 12835 "\n" 12836 "UNI_GOKU\n" 12837 "\n" 12838 "void main()\n" 12839 "{\n" 12840 " vec4 result = vec4(0, 1, 0, 1);\n" 12841 "\n" 12842 "VERIFICATION" 12843 "\n" 12844 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 12845 "}\n" 12846 "\n"; 12847 12848 static const GLchar* fragment_shader_template = "VERSION\n" 12849 "#extension GL_ARB_shader_image_load_store : enable\n" 12850 "\n" 12851 "in vec4 gs_fs_result;\n" 12852 "out vec4 fs_out_result;\n" 12853 "\n" 12854 "UNI_GOKU\n" 12855 "\n" 12856 "void main()\n" 12857 "{\n" 12858 " vec4 result = vec4(0, 1, 0, 1);\n" 12859 "\n" 12860 "VERIFICATION" 12861 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 12862 " {\n" 12863 " result = vec4(1, 0, 0, 1);\n" 12864 " }\n" 12865 "\n" 12866 " fs_out_result = result;\n" 12867 "}\n" 12868 "\n"; 12869 12870 static const GLchar* geometry_shader_template = "VERSION\n" 12871 "#extension GL_ARB_shader_image_load_store : enable\n" 12872 "\n" 12873 "layout(points) in;\n" 12874 "layout(triangle_strip, max_vertices = 4) out;\n" 12875 "\n" 12876 "in vec4 tes_gs_result[];\n" 12877 "out vec4 gs_fs_result;\n" 12878 "\n" 12879 "UNI_GOKU\n" 12880 "\n" 12881 "void main()\n" 12882 "{\n" 12883 " vec4 result = vec4(0, 1, 0, 1);\n" 12884 "\n" 12885 "VERIFICATION" 12886 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 12887 " {\n" 12888 " result = vec4(1, 0, 0, 1);\n" 12889 " }\n" 12890 "\n" 12891 " gs_fs_result = result;\n" 12892 " gl_Position = vec4(-1, -1, 0, 1);\n" 12893 " EmitVertex();\n" 12894 " gs_fs_result = result;\n" 12895 " gl_Position = vec4(-1, 1, 0, 1);\n" 12896 " EmitVertex();\n" 12897 " gs_fs_result = result;\n" 12898 " gl_Position = vec4(1, -1, 0, 1);\n" 12899 " EmitVertex();\n" 12900 " gs_fs_result = result;\n" 12901 " gl_Position = vec4(1, 1, 0, 1);\n" 12902 " EmitVertex();\n" 12903 "}\n" 12904 "\n"; 12905 12906 static const GLchar* tess_ctrl_shader_template = 12907 "VERSION\n" 12908 "#extension GL_ARB_shader_image_load_store : enable\n" 12909 "\n" 12910 "layout(vertices = 1) out;\n" 12911 "\n" 12912 "in vec4 vs_tcs_result[];\n" 12913 "out vec4 tcs_tes_result[];\n" 12914 "\n" 12915 "UNI_GOKU\n" 12916 "\n" 12917 "void main()\n" 12918 "{\n" 12919 " vec4 result = vec4(0, 1, 0, 1);\n" 12920 "\n" 12921 "VERIFICATION" 12922 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 12923 " {\n" 12924 " result = vec4(1, 0, 0, 1);\n" 12925 " }\n" 12926 "\n" 12927 " tcs_tes_result[gl_InvocationID] = result;\n" 12928 "\n" 12929 " gl_TessLevelOuter[0] = 1.0;\n" 12930 " gl_TessLevelOuter[1] = 1.0;\n" 12931 " gl_TessLevelOuter[2] = 1.0;\n" 12932 " gl_TessLevelOuter[3] = 1.0;\n" 12933 " gl_TessLevelInner[0] = 1.0;\n" 12934 " gl_TessLevelInner[1] = 1.0;\n" 12935 "}\n" 12936 "\n"; 12937 12938 static const GLchar* tess_eval_shader_template = "VERSION\n" 12939 "#extension GL_ARB_shader_image_load_store : enable\n" 12940 "\n" 12941 "layout(isolines, point_mode) in;\n" 12942 "\n" 12943 "in vec4 tcs_tes_result[];\n" 12944 "out vec4 tes_gs_result;\n" 12945 "\n" 12946 "UNI_GOKU\n" 12947 "\n" 12948 "void main()\n" 12949 "{\n" 12950 " vec4 result = vec4(0, 1, 0, 1);\n" 12951 "\n" 12952 "VERIFICATION" 12953 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 12954 " {\n" 12955 " result = vec4(1, 0, 0, 1);\n" 12956 " }\n" 12957 "\n" 12958 " tes_gs_result = result;\n" 12959 "}\n" 12960 "\n"; 12961 12962 static const GLchar* vertex_shader_template = "VERSION\n" 12963 "#extension GL_ARB_shader_image_load_store : enable\n" 12964 "\n" 12965 "out vec4 vs_tcs_result;\n" 12966 "\n" 12967 "UNI_GOKU\n" 12968 "\n" 12969 "void main()\n" 12970 "{\n" 12971 " vec4 result = vec4(0, 1, 0, 1);\n" 12972 "\n" 12973 "VERIFICATION" 12974 "\n" 12975 " vs_tcs_result = result;\n" 12976 "}\n" 12977 "\n"; 12978 12979 const GLchar* shader_template = 0; 12980 12981 switch (in_stage) 12982 { 12983 case Utils::COMPUTE_SHADER: 12984 shader_template = compute_shader_template; 12985 break; 12986 case Utils::FRAGMENT_SHADER: 12987 shader_template = fragment_shader_template; 12988 break; 12989 case Utils::GEOMETRY_SHADER: 12990 shader_template = geometry_shader_template; 12991 break; 12992 case Utils::TESS_CTRL_SHADER: 12993 shader_template = tess_ctrl_shader_template; 12994 break; 12995 case Utils::TESS_EVAL_SHADER: 12996 shader_template = tess_eval_shader_template; 12997 break; 12998 case Utils::VERTEX_SHADER: 12999 shader_template = vertex_shader_template; 13000 break; 13001 default: 13002 TCU_FAIL("Invalid enum"); 13003 break; 13004 } 13005 13006 out_source.m_parts[0].m_code = shader_template; 13007 13008 size_t position = 0; 13009 13010 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 13011 out_source.m_parts[0].m_code); 13012 13013 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 13014 13015 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 13016 } 13017 13018 /** Overwritte of prepareUniforms method, set up values for unit_left and unit_right 13019 * 13020 * @param program Current program 13021 **/ 13022 void BindingImageAPIOverrideTest::prepareUniforms(Utils::program& program) 13023 { 13024 static const GLuint goku_data = 0x000000ff; 13025 static const GLint new_binding = 7; 13026 13027 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 13028 13029 const GLint uniform_location = program.getUniformLocation("goku"); 13030 if (-1 == uniform_location) 13031 { 13032 TCU_FAIL("Uniform is inactive"); 13033 } 13034 13035 gl.uniform1i(uniform_location, new_binding); 13036 13037 GLint binding = -1; 13038 13039 gl.getUniformiv(program.m_program_object_id, uniform_location, &binding); 13040 GLU_EXPECT_NO_ERROR(gl.getError(), "getUniformiv"); 13041 13042 if (new_binding != binding) 13043 { 13044 TCU_FAIL("Wrong binding value"); 13045 return; 13046 } 13047 13048 prepareTexture(m_goku_texture, Utils::buffer(m_context), Utils::TEX_2D, goku_data, new_binding); 13049 } 13050 13051 /** Overwrite of releaseResource method, release extra texture 13052 * 13053 * @param ignored 13054 **/ 13055 void BindingImageAPIOverrideTest::releaseResource() 13056 { 13057 m_goku_texture.release(); 13058 } 13059 13060 /** Constructor 13061 * 13062 * @param context Test context 13063 **/ 13064 BindingImageInvalidTest::BindingImageInvalidTest(deqp::Context& context) 13065 : NegativeTestBase(context, "binding_image_invalid", "Test verifies invalid binding values") 13066 { 13067 /* Nothing to be done here */ 13068 } 13069 13070 /** Set up next test case 13071 * 13072 * @param test_case_index Index of next test case 13073 * 13074 * @return false if there is no more test cases, true otherwise 13075 **/ 13076 bool BindingImageInvalidTest::prepareNextTestCase(glw::GLuint test_case_index) 13077 { 13078 switch (test_case_index) 13079 { 13080 case (glw::GLuint)-1: 13081 m_case = TEST_CASES_MAX; 13082 break; 13083 case NEGATIVE_VALUE: 13084 case VARIABLE_NAME: 13085 case STD140: 13086 case MISSING: 13087 m_case = (TESTCASES)test_case_index; 13088 break; 13089 default: 13090 return false; 13091 } 13092 13093 return true; 13094 } 13095 13096 /** Prepare source for given shader stage 13097 * 13098 * @param in_stage Shader stage, compute shader will use 430 13099 * @param in_use_version_400 Select if 400 or 420 should be used 13100 * @param out_source Prepared shader source instance 13101 **/ 13102 void BindingImageInvalidTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 13103 Utils::shaderSource& out_source) 13104 { 13105 static const GLchar* uni_goku = "layout(binding BINDING, rgba8) uniform image2D goku;\n"; 13106 13107 static const GLchar* verification_snippet = " vec4 goku_color = imageLoad(goku, ivec2(0,0));\n" 13108 "\n" 13109 " if (vec4(1, 0, 0, 0) != goku_color)\n" 13110 " {\n" 13111 " result = vec4(1, 0, 0, 1);\n" 13112 " }\n"; 13113 13114 static const GLchar* compute_shader_template = 13115 "VERSION\n" 13116 "#extension GL_ARB_shader_image_load_store : enable\n" 13117 "\n" 13118 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 13119 "\n" 13120 "writeonly uniform image2D uni_image;\n" 13121 "\n" 13122 "UNI_GOKU\n" 13123 "\n" 13124 "void main()\n" 13125 "{\n" 13126 " vec4 result = vec4(0, 1, 0, 1);\n" 13127 "\n" 13128 "VERIFICATION" 13129 "\n" 13130 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 13131 "}\n" 13132 "\n"; 13133 13134 static const GLchar* fragment_shader_template = "VERSION\n" 13135 "#extension GL_ARB_shader_image_load_store : enable\n" 13136 "\n" 13137 "in vec4 gs_fs_result;\n" 13138 "out vec4 fs_out_result;\n" 13139 "\n" 13140 "UNI_GOKU\n" 13141 "\n" 13142 "void main()\n" 13143 "{\n" 13144 " vec4 result = vec4(0, 1, 0, 1);\n" 13145 "\n" 13146 "VERIFICATION" 13147 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 13148 " {\n" 13149 " result = vec4(1, 0, 0, 1);\n" 13150 " }\n" 13151 "\n" 13152 " fs_out_result = result;\n" 13153 "}\n" 13154 "\n"; 13155 13156 static const GLchar* geometry_shader_template = "VERSION\n" 13157 "#extension GL_ARB_shader_image_load_store : enable\n" 13158 "\n" 13159 "layout(points) in;\n" 13160 "layout(triangle_strip, max_vertices = 4) out;\n" 13161 "\n" 13162 "in vec4 tes_gs_result[];\n" 13163 "out vec4 gs_fs_result;\n" 13164 "\n" 13165 "UNI_GOKU\n" 13166 "\n" 13167 "void main()\n" 13168 "{\n" 13169 " vec4 result = vec4(0, 1, 0, 1);\n" 13170 "\n" 13171 "VERIFICATION" 13172 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 13173 " {\n" 13174 " result = vec4(1, 0, 0, 1);\n" 13175 " }\n" 13176 "\n" 13177 " gs_fs_result = result;\n" 13178 " gl_Position = vec4(-1, -1, 0, 1);\n" 13179 " EmitVertex();\n" 13180 " gs_fs_result = result;\n" 13181 " gl_Position = vec4(-1, 1, 0, 1);\n" 13182 " EmitVertex();\n" 13183 " gs_fs_result = result;\n" 13184 " gl_Position = vec4(1, -1, 0, 1);\n" 13185 " EmitVertex();\n" 13186 " gs_fs_result = result;\n" 13187 " gl_Position = vec4(1, 1, 0, 1);\n" 13188 " EmitVertex();\n" 13189 "}\n" 13190 "\n"; 13191 13192 static const GLchar* tess_ctrl_shader_template = 13193 "VERSION\n" 13194 "#extension GL_ARB_shader_image_load_store : enable\n" 13195 "\n" 13196 "layout(vertices = 1) out;\n" 13197 "\n" 13198 "in vec4 vs_tcs_result[];\n" 13199 "out vec4 tcs_tes_result[];\n" 13200 "\n" 13201 "UNI_GOKU\n" 13202 "\n" 13203 "void main()\n" 13204 "{\n" 13205 " vec4 result = vec4(0, 1, 0, 1);\n" 13206 "\n" 13207 "VERIFICATION" 13208 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 13209 " {\n" 13210 " result = vec4(1, 0, 0, 1);\n" 13211 " }\n" 13212 "\n" 13213 " tcs_tes_result[gl_InvocationID] = result;\n" 13214 "\n" 13215 " gl_TessLevelOuter[0] = 1.0;\n" 13216 " gl_TessLevelOuter[1] = 1.0;\n" 13217 " gl_TessLevelOuter[2] = 1.0;\n" 13218 " gl_TessLevelOuter[3] = 1.0;\n" 13219 " gl_TessLevelInner[0] = 1.0;\n" 13220 " gl_TessLevelInner[1] = 1.0;\n" 13221 "}\n" 13222 "\n"; 13223 13224 static const GLchar* tess_eval_shader_template = "VERSION\n" 13225 "#extension GL_ARB_shader_image_load_store : enable\n" 13226 "\n" 13227 "layout(isolines, point_mode) in;\n" 13228 "\n" 13229 "in vec4 tcs_tes_result[];\n" 13230 "out vec4 tes_gs_result;\n" 13231 "\n" 13232 "UNI_GOKU\n" 13233 "\n" 13234 "void main()\n" 13235 "{\n" 13236 " vec4 result = vec4(0, 1, 0, 1);\n" 13237 "\n" 13238 "VERIFICATION" 13239 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 13240 " {\n" 13241 " result = vec4(1, 0, 0, 1);\n" 13242 " }\n" 13243 "\n" 13244 " tes_gs_result = result;\n" 13245 "}\n" 13246 "\n"; 13247 13248 static const GLchar* vertex_shader_template = "VERSION\n" 13249 "#extension GL_ARB_shader_image_load_store : enable\n" 13250 "\n" 13251 "out vec4 vs_tcs_result;\n" 13252 "\n" 13253 "UNI_GOKU\n" 13254 "\n" 13255 "void main()\n" 13256 "{\n" 13257 " vec4 result = vec4(0, 1, 0, 1);\n" 13258 "\n" 13259 "VERIFICATION" 13260 "\n" 13261 " vs_tcs_result = result;\n" 13262 "}\n" 13263 "\n"; 13264 13265 const GLchar* shader_template = 0; 13266 13267 switch (in_stage) 13268 { 13269 case Utils::COMPUTE_SHADER: 13270 shader_template = compute_shader_template; 13271 break; 13272 case Utils::FRAGMENT_SHADER: 13273 shader_template = fragment_shader_template; 13274 break; 13275 case Utils::GEOMETRY_SHADER: 13276 shader_template = geometry_shader_template; 13277 break; 13278 case Utils::TESS_CTRL_SHADER: 13279 shader_template = tess_ctrl_shader_template; 13280 break; 13281 case Utils::TESS_EVAL_SHADER: 13282 shader_template = tess_eval_shader_template; 13283 break; 13284 case Utils::VERTEX_SHADER: 13285 shader_template = vertex_shader_template; 13286 break; 13287 default: 13288 TCU_FAIL("Invalid enum"); 13289 break; 13290 } 13291 13292 out_source.m_parts[0].m_code = shader_template; 13293 13294 size_t position = 0; 13295 13296 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 13297 out_source.m_parts[0].m_code); 13298 13299 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 13300 13301 Utils::replaceAllTokens("UNI_GOKU", uni_goku, out_source.m_parts[0].m_code); 13302 13303 Utils::replaceAllTokens("BINDING", getCaseString(m_case), out_source.m_parts[0].m_code); 13304 } 13305 13306 const GLchar* BindingImageInvalidTest::getCaseString(TESTCASES test_case) 13307 { 13308 (void)test_case; 13309 const GLchar* binding = 0; 13310 13311 switch (m_case) 13312 { 13313 case NEGATIVE_VALUE: 13314 binding = "= -1"; 13315 break; 13316 case VARIABLE_NAME: 13317 binding = "= goku"; 13318 break; 13319 case STD140: 13320 binding = "= std140"; 13321 break; 13322 case MISSING: 13323 binding = ""; 13324 break; 13325 case TEST_CASES_MAX: 13326 binding = "= 0"; 13327 break; 13328 default: 13329 TCU_FAIL("Invalid enum"); 13330 } 13331 13332 return binding; 13333 } 13334 13335 /* Constants used by InitializerListTest */ 13336 const GLfloat InitializerListTest::m_value = 0.0625f; 13337 13338 /** Constructor 13339 * 13340 * @param context Test context 13341 **/ 13342 InitializerListTest::InitializerListTest(deqp::Context& context) 13343 : GLSLTestBase(context, "initializer_list", "Test verifies initializer lists") 13344 { 13345 /* Nothing to be done here */ 13346 } 13347 13348 /** Set up next test case 13349 * 13350 * @param test_case_index Index of next test case 13351 * 13352 * @return false if there is no more test cases, true otherwise 13353 **/ 13354 bool InitializerListTest::prepareNextTestCase(glw::GLuint test_case_index) 13355 { 13356 m_current_test_case_index = test_case_index; 13357 13358 if ((glw::GLuint)-1 == test_case_index) 13359 { 13360 m_current_test_case_index = 0; 13361 return true; 13362 } 13363 else if (m_test_cases.size() <= test_case_index) 13364 { 13365 return false; 13366 } 13367 13368 logTestCaseName(); 13369 13370 return true; 13371 } 13372 13373 /** Overwritte of prepareUniforms method 13374 * 13375 * @param program Current program 13376 **/ 13377 void InitializerListTest::prepareUniforms(Utils::program& program) 13378 { 13379 static const GLfloat float_data[16] = { m_value, m_value, m_value, m_value, m_value, m_value, m_value, m_value, 13380 m_value, m_value, m_value, m_value, m_value, m_value, m_value, m_value }; 13381 13382 program.uniform("uni_matrix", Utils::FLOAT, 4, 4, float_data); 13383 } 13384 13385 /** Prepare source for given shader stage 13386 * 13387 * @param in_stage Shader stage, compute shader will use 430 13388 * @param in_use_version_400 Select if 400 or 420 should be used 13389 * @param out_source Prepared shader source instance 13390 **/ 13391 void InitializerListTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 13392 Utils::shaderSource& out_source) 13393 { 13394 static const GLchar* verification_snippet = " TYPE_NAME variableARRAY_DEFINITION = INITIALIZATION;\n" 13395 "\n" 13396 " float sum = SUM;\n" 13397 "\n" 13398 " if (EXPECTED_VALUE != sum)\n" 13399 " {\n" 13400 " result = vec4(1, 0, 0, 1);\n" 13401 " }\n"; 13402 13403 static const GLchar* compute_shader_template = 13404 "VERSION\n" 13405 "\n" 13406 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 13407 "\n" 13408 "writeonly uniform image2D uni_image;\n" 13409 " uniform mat4 uni_matrix;\n" 13410 "\n" 13411 "TYPE_DEFINITION\n" 13412 "\n" 13413 "void main()\n" 13414 "{\n" 13415 " vec4 result = vec4(0, 1, 0, 1);\n" 13416 "\n" 13417 "VERIFICATION" 13418 "\n" 13419 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 13420 "}\n" 13421 "\n"; 13422 13423 static const GLchar* fragment_shader_template = "VERSION\n" 13424 "\n" 13425 "in vec4 gs_fs_result;\n" 13426 "out vec4 fs_out_result;\n" 13427 "\n" 13428 "uniform mat4 uni_matrix;\n" 13429 "\n" 13430 "TYPE_DEFINITION\n" 13431 "\n" 13432 "void main()\n" 13433 "{\n" 13434 " vec4 result = vec4(0, 1, 0, 1);\n" 13435 "\n" 13436 "VERIFICATION" 13437 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 13438 " {\n" 13439 " result = vec4(1, 0, 0, 1);\n" 13440 " }\n" 13441 "\n" 13442 " fs_out_result = result;\n" 13443 "}\n" 13444 "\n"; 13445 13446 static const GLchar* geometry_shader_template = "VERSION\n" 13447 "\n" 13448 "layout(points) in;\n" 13449 "layout(triangle_strip, max_vertices = 4) out;\n" 13450 "\n" 13451 "in vec4 tes_gs_result[];\n" 13452 "out vec4 gs_fs_result;\n" 13453 "\n" 13454 "uniform mat4 uni_matrix;\n" 13455 "\n" 13456 "TYPE_DEFINITION\n" 13457 "\n" 13458 "void main()\n" 13459 "{\n" 13460 " vec4 result = vec4(0, 1, 0, 1);\n" 13461 "\n" 13462 "VERIFICATION" 13463 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 13464 " {\n" 13465 " result = vec4(1, 0, 0, 1);\n" 13466 " }\n" 13467 "\n" 13468 " gs_fs_result = result;\n" 13469 " gl_Position = vec4(-1, -1, 0, 1);\n" 13470 " EmitVertex();\n" 13471 " gs_fs_result = result;\n" 13472 " gl_Position = vec4(-1, 1, 0, 1);\n" 13473 " EmitVertex();\n" 13474 " gs_fs_result = result;\n" 13475 " gl_Position = vec4(1, -1, 0, 1);\n" 13476 " EmitVertex();\n" 13477 " gs_fs_result = result;\n" 13478 " gl_Position = vec4(1, 1, 0, 1);\n" 13479 " EmitVertex();\n" 13480 "}\n" 13481 "\n"; 13482 13483 static const GLchar* tess_ctrl_shader_template = 13484 "VERSION\n" 13485 "\n" 13486 "layout(vertices = 1) out;\n" 13487 "\n" 13488 "in vec4 vs_tcs_result[];\n" 13489 "out vec4 tcs_tes_result[];\n" 13490 "\n" 13491 "uniform mat4 uni_matrix;\n" 13492 "\n" 13493 "TYPE_DEFINITION\n" 13494 "\n" 13495 "void main()\n" 13496 "{\n" 13497 " vec4 result = vec4(0, 1, 0, 1);\n" 13498 "\n" 13499 "VERIFICATION" 13500 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 13501 " {\n" 13502 " result = vec4(1, 0, 0, 1);\n" 13503 " }\n" 13504 "\n" 13505 " tcs_tes_result[gl_InvocationID] = result;\n" 13506 "\n" 13507 " gl_TessLevelOuter[0] = 1.0;\n" 13508 " gl_TessLevelOuter[1] = 1.0;\n" 13509 " gl_TessLevelOuter[2] = 1.0;\n" 13510 " gl_TessLevelOuter[3] = 1.0;\n" 13511 " gl_TessLevelInner[0] = 1.0;\n" 13512 " gl_TessLevelInner[1] = 1.0;\n" 13513 "}\n" 13514 "\n"; 13515 13516 static const GLchar* tess_eval_shader_template = "VERSION\n" 13517 "\n" 13518 "layout(isolines, point_mode) in;\n" 13519 "\n" 13520 "in vec4 tcs_tes_result[];\n" 13521 "out vec4 tes_gs_result;\n" 13522 "\n" 13523 "uniform mat4 uni_matrix;\n" 13524 "\n" 13525 "TYPE_DEFINITION\n" 13526 "\n" 13527 "void main()\n" 13528 "{\n" 13529 " vec4 result = vec4(0, 1, 0, 1);\n" 13530 "\n" 13531 "VERIFICATION" 13532 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 13533 " {\n" 13534 " result = vec4(1, 0, 0, 1);\n" 13535 " }\n" 13536 "\n" 13537 " tes_gs_result = result;\n" 13538 "}\n" 13539 "\n"; 13540 13541 static const GLchar* vertex_shader_template = "VERSION\n" 13542 "\n" 13543 "out vec4 vs_tcs_result;\n" 13544 "\n" 13545 "uniform mat4 uni_matrix;\n" 13546 "\n" 13547 "TYPE_DEFINITION\n" 13548 "\n" 13549 "void main()\n" 13550 "{\n" 13551 " vec4 result = vec4(0, 1, 0, 1);\n" 13552 "\n" 13553 "VERIFICATION" 13554 "\n" 13555 " vs_tcs_result = result;\n" 13556 "}\n" 13557 "\n"; 13558 13559 const std::string& array_definition = getArrayDefinition(); 13560 const std::string& expected_value = getExpectedValue(); 13561 const std::string& initialization = getInitialization(); 13562 const GLchar* shader_template = 0; 13563 const std::string& sum = getSum(); 13564 const std::string& type_definition = getTypeDefinition(); 13565 const std::string& type_name = getTypeName(); 13566 13567 switch (in_stage) 13568 { 13569 case Utils::COMPUTE_SHADER: 13570 shader_template = compute_shader_template; 13571 break; 13572 case Utils::FRAGMENT_SHADER: 13573 shader_template = fragment_shader_template; 13574 break; 13575 case Utils::GEOMETRY_SHADER: 13576 shader_template = geometry_shader_template; 13577 break; 13578 case Utils::TESS_CTRL_SHADER: 13579 shader_template = tess_ctrl_shader_template; 13580 break; 13581 case Utils::TESS_EVAL_SHADER: 13582 shader_template = tess_eval_shader_template; 13583 break; 13584 case Utils::VERTEX_SHADER: 13585 shader_template = vertex_shader_template; 13586 break; 13587 default: 13588 TCU_FAIL("Invalid enum"); 13589 break; 13590 } 13591 13592 out_source.m_parts[0].m_code = shader_template; 13593 13594 size_t position = 0; 13595 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 13596 out_source.m_parts[0].m_code); 13597 13598 Utils::replaceToken("TYPE_DEFINITION", position, type_definition.c_str(), out_source.m_parts[0].m_code); 13599 13600 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 13601 13602 position -= strlen(verification_snippet); 13603 13604 Utils::replaceToken("TYPE_NAME", position, type_name.c_str(), out_source.m_parts[0].m_code); 13605 13606 Utils::replaceToken("ARRAY_DEFINITION", position, array_definition.c_str(), out_source.m_parts[0].m_code); 13607 13608 Utils::replaceToken("INITIALIZATION", position, initialization.c_str(), out_source.m_parts[0].m_code); 13609 13610 Utils::replaceToken("SUM", position, sum.c_str(), out_source.m_parts[0].m_code); 13611 13612 Utils::replaceToken("EXPECTED_VALUE", position, expected_value.c_str(), out_source.m_parts[0].m_code); 13613 } 13614 13615 /** Prepare test cases 13616 * 13617 * @return true 13618 **/ 13619 bool InitializerListTest::testInit() 13620 { 13621 for (GLuint i = 0; i < TESTED_INITIALIZERS_MAX; ++i) 13622 { 13623 const TESTED_INITIALIZERS l_init = (TESTED_INITIALIZERS)i; 13624 13625 testCase test_case = { l_init, 1, 1 }; 13626 13627 switch (l_init) 13628 { 13629 case VECTOR: 13630 case ARRAY_VECTOR_CTR: 13631 case ARRAY_VECTOR_LIST: 13632 case UNSIZED_ARRAY_VECTOR: 13633 for (GLuint row = 2; row <= 4; ++row) 13634 { 13635 test_case.m_n_rows = row; 13636 13637 m_test_cases.push_back(test_case); 13638 } 13639 13640 break; 13641 13642 case MATRIX: 13643 case MATRIX_ROWS: 13644 case ARRAY_MATRIX_CTR: 13645 case ARRAY_MATRIX_LIST: 13646 case UNSIZED_ARRAY_MATRIX: 13647 for (GLuint col = 2; col <= 4; ++col) 13648 { 13649 for (GLuint row = 2; row <= 4; ++row) 13650 { 13651 test_case.m_n_cols = col; 13652 test_case.m_n_rows = row; 13653 13654 m_test_cases.push_back(test_case); 13655 } 13656 } 13657 13658 break; 13659 13660 case ARRAY_SCALAR: 13661 case UNSIZED_ARRAY_SCALAR: 13662 m_test_cases.push_back(test_case); 13663 13664 break; 13665 13666 case STRUCT: 13667 case ARRAY_STRUCT: 13668 case NESTED_STRUCT_CTR: 13669 case NESTED_STRUCT_LIST: 13670 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 13671 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 13672 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 13673 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 13674 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 13675 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 13676 case UNSIZED_ARRAY_STRUCT: 13677 test_case.m_n_rows = 4; 13678 m_test_cases.push_back(test_case); 13679 13680 break; 13681 default: 13682 DE_ASSERT(0); 13683 break; 13684 } 13685 } 13686 13687 return true; 13688 } 13689 13690 /** Get string representing "[SIZE]" for current test case 13691 * 13692 * @return String 13693 **/ 13694 std::string InitializerListTest::getArrayDefinition() 13695 { 13696 const testCase& test_case = m_test_cases[m_current_test_case_index]; 13697 13698 std::string array_definition; 13699 13700 switch (test_case.m_initializer) 13701 { 13702 case VECTOR: 13703 case MATRIX: 13704 case MATRIX_ROWS: 13705 case STRUCT: 13706 case NESTED_STRUCT_CTR: 13707 case NESTED_STRUCT_LIST: 13708 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 13709 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 13710 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 13711 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 13712 array_definition = ""; 13713 break; 13714 case ARRAY_SCALAR: 13715 case ARRAY_VECTOR_CTR: 13716 case ARRAY_VECTOR_LIST: 13717 case ARRAY_MATRIX_CTR: 13718 case ARRAY_MATRIX_LIST: 13719 case ARRAY_STRUCT: 13720 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 13721 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 13722 array_definition = "[4]"; 13723 break; 13724 case UNSIZED_ARRAY_SCALAR: 13725 case UNSIZED_ARRAY_VECTOR: 13726 case UNSIZED_ARRAY_MATRIX: 13727 case UNSIZED_ARRAY_STRUCT: 13728 array_definition = "[]"; 13729 break; 13730 default: 13731 TCU_FAIL("Invalid enum"); 13732 break; 13733 } 13734 13735 return array_definition; 13736 } 13737 13738 /** Get string representing expected value of sum for current test case 13739 * 13740 * @return String 13741 **/ 13742 std::string InitializerListTest::getExpectedValue() 13743 { 13744 const testCase& test_case = m_test_cases[m_current_test_case_index]; 13745 13746 GLfloat value = 0.0f; 13747 13748 switch (test_case.m_initializer) 13749 { 13750 case VECTOR: 13751 case MATRIX: 13752 case MATRIX_ROWS: 13753 value = (GLfloat)(test_case.m_n_cols * test_case.m_n_rows); 13754 break; 13755 case ARRAY_VECTOR_CTR: 13756 case ARRAY_VECTOR_LIST: 13757 case ARRAY_MATRIX_CTR: 13758 case ARRAY_MATRIX_LIST: 13759 case UNSIZED_ARRAY_VECTOR: 13760 case UNSIZED_ARRAY_MATRIX: 13761 value = (GLfloat)(test_case.m_n_cols * test_case.m_n_rows) * 4.0f; 13762 break; 13763 case ARRAY_SCALAR: 13764 case UNSIZED_ARRAY_SCALAR: 13765 value = 4.0f; 13766 break; 13767 case STRUCT: 13768 value = 8.0f; 13769 break; 13770 case NESTED_STRUCT_CTR: 13771 case NESTED_STRUCT_LIST: 13772 value = 12.0f; 13773 break; 13774 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 13775 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 13776 value = 16.0f; 13777 break; 13778 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 13779 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 13780 value = 28.0f; 13781 break; 13782 case ARRAY_STRUCT: 13783 case UNSIZED_ARRAY_STRUCT: 13784 value = 32.0f; 13785 break; 13786 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 13787 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 13788 value = 48.0f; 13789 break; 13790 default: 13791 TCU_FAIL("Invalid enum"); 13792 break; 13793 } 13794 13795 value *= m_value; 13796 13797 std::string expected_value; 13798 expected_value.resize(64, 0); 13799 13800 sprintf(&expected_value[0], "%f", value); 13801 13802 return expected_value; 13803 } 13804 13805 /** Get string representing initialization list for current test case 13806 * 13807 * @return String 13808 **/ 13809 std::string InitializerListTest::getInitialization() 13810 { 13811 const testCase& test_case = m_test_cases[m_current_test_case_index]; 13812 13813 std::string initialization; 13814 13815 switch (test_case.m_initializer) 13816 { 13817 case VECTOR: 13818 initialization.append(getVectorInitializer(0 /*column*/, test_case.m_n_rows)); 13819 13820 break; 13821 13822 case MATRIX: 13823 initialization = "{ "; 13824 initialization.append(getVectorArrayList(test_case.m_n_cols, test_case.m_n_rows)); 13825 initialization.append(" }"); 13826 13827 break; 13828 13829 case MATRIX_ROWS: 13830 { 13831 initialization = "{ "; 13832 initialization.append(getVectorArrayCtr(test_case.m_n_cols, test_case.m_n_rows)); 13833 initialization.append(" }"); 13834 } 13835 break; 13836 13837 case STRUCT: 13838 initialization = "{ "; 13839 initialization.append(getVectorInitializer(0 /* column */, test_case.m_n_rows)); 13840 initialization.append(", "); 13841 initialization.append(getVectorInitializer(2 /* column */, test_case.m_n_rows)); 13842 initialization.append(" }"); 13843 13844 break; 13845 13846 case ARRAY_SCALAR: 13847 case UNSIZED_ARRAY_SCALAR: 13848 initialization = "{ "; 13849 initialization.append(getVectorValues(0 /* column */, 4 /* size */)); 13850 initialization.append(" }"); 13851 13852 break; 13853 13854 case ARRAY_VECTOR_LIST: 13855 case UNSIZED_ARRAY_VECTOR: 13856 initialization = "{ "; 13857 initialization.append(getVectorArrayList(4 /* columns */, test_case.m_n_rows)); 13858 initialization.append(" }"); 13859 13860 break; 13861 13862 case ARRAY_VECTOR_CTR: 13863 initialization = "{ "; 13864 initialization.append(getVectorArrayCtr(4 /* columns */, test_case.m_n_rows)); 13865 initialization.append(" }"); 13866 13867 break; 13868 13869 case ARRAY_MATRIX_LIST: 13870 case UNSIZED_ARRAY_MATRIX: 13871 initialization = "{ "; 13872 13873 for (GLuint i = 0; i < 4; ++i) 13874 { 13875 initialization.append("{ "); 13876 initialization.append(getVectorArrayList(test_case.m_n_cols, test_case.m_n_rows)); 13877 initialization.append(" }"); 13878 13879 if (i + 1 < 4) 13880 { 13881 initialization.append(", "); 13882 } 13883 } 13884 13885 initialization.append(" }"); 13886 13887 break; 13888 13889 case ARRAY_MATRIX_CTR: 13890 { 13891 const std::string& type_name = Utils::getTypeName(Utils::FLOAT, test_case.m_n_cols, test_case.m_n_rows); 13892 13893 initialization = "{ "; 13894 13895 for (GLuint i = 0; i < 4; ++i) 13896 { 13897 initialization.append(type_name); 13898 initialization.append("("); 13899 for (GLuint col = 0; col < test_case.m_n_cols; ++col) 13900 { 13901 initialization.append(getVectorValues(col, test_case.m_n_rows)); 13902 13903 if (col + 1 < test_case.m_n_cols) 13904 { 13905 initialization.append(", "); 13906 } 13907 } 13908 initialization.append(")"); 13909 13910 if (i + 1 < 4) 13911 { 13912 initialization.append(", "); 13913 } 13914 } 13915 13916 initialization.append(" }"); 13917 } 13918 break; 13919 13920 case ARRAY_STRUCT: 13921 case UNSIZED_ARRAY_STRUCT: 13922 initialization = "{ "; 13923 13924 for (GLuint i = 0; i < 4; ++i) 13925 { 13926 initialization.append("{ "); 13927 initialization.append(getVectorInitializer(0 /* column */, test_case.m_n_rows)); 13928 initialization.append(", "); 13929 initialization.append(getVectorInitializer(2 /* column */, test_case.m_n_rows)); 13930 initialization.append(" }"); 13931 13932 if (i + 1 < 4) 13933 { 13934 initialization.append(", "); 13935 } 13936 } 13937 13938 initialization.append(" }"); 13939 13940 break; 13941 13942 case NESTED_STRUCT_CTR: 13943 initialization = "StructureWithStructure(BasicStructure("; 13944 initialization.append(getVectorConstructor(0 /* column */, 4)); 13945 initialization.append(", "); 13946 initialization.append(getVectorConstructor(2 /* column */, 4)); 13947 initialization.append("), "); 13948 initialization.append(getVectorConstructor(3 /* column */, 4)); 13949 initialization.append(")"); 13950 13951 break; 13952 13953 case NESTED_STRUCT_LIST: 13954 initialization = "{ { "; 13955 initialization.append(getVectorInitializer(0 /* column */, 4)); 13956 initialization.append(", "); 13957 initialization.append(getVectorInitializer(2 /* column */, 4)); 13958 initialization.append(" }, "); 13959 initialization.append(getVectorInitializer(3 /* column */, 4)); 13960 initialization.append(" }"); 13961 13962 break; 13963 13964 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 13965 initialization = "{ "; 13966 initialization.append(getVectorInitializer(0 /* column */, 4)); 13967 initialization.append(", { "); 13968 13969 for (GLuint i = 0; i < 3; ++i) 13970 { 13971 initialization.append("{ "); 13972 initialization.append(getVectorInitializer(2 /* column */, 4)); 13973 initialization.append(", "); 13974 initialization.append(getVectorInitializer(3 /* column */, 4)); 13975 initialization.append(" }"); 13976 13977 if (i + 1 < 3) 13978 { 13979 initialization.append(", "); 13980 } 13981 } 13982 13983 initialization.append(" } }"); 13984 13985 break; 13986 13987 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 13988 initialization = "{ "; 13989 initialization.append(getVectorConstructor(0 /* column */, 4)); 13990 initialization.append(", { "); 13991 13992 for (GLuint i = 0; i < 3; ++i) 13993 { 13994 initialization.append("{ "); 13995 initialization.append(getVectorInitializer(2 /* column */, 4)); 13996 initialization.append(", "); 13997 initialization.append(getVectorConstructor(3 /* column */, 4)); 13998 initialization.append(" }"); 13999 14000 if (i + 1 < 3) 14001 { 14002 initialization.append(", "); 14003 } 14004 } 14005 14006 initialization.append(" } }"); 14007 14008 break; 14009 14010 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 14011 initialization = "{ "; 14012 14013 for (GLuint i = 0; i < 4; ++i) 14014 { 14015 initialization.append("{ { "); 14016 14017 initialization.append(getVectorInitializer(0 /* column */, 4)); 14018 initialization.append(", "); 14019 initialization.append(getVectorInitializer(1 /* column */, 4)); 14020 14021 initialization.append(" }, "); 14022 14023 initialization.append(getVectorInitializer(2 /* column */, 4)); 14024 14025 initialization.append(" }"); 14026 14027 if (i + 1 < 4) 14028 { 14029 initialization.append(", "); 14030 } 14031 } 14032 14033 initialization.append(" }"); 14034 14035 break; 14036 14037 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 14038 initialization = "{\n"; 14039 14040 for (GLuint i = 0; i < 2; ++i) 14041 { 14042 initialization.append("StructureWithStructure(\n"); 14043 initialization.append("BasicStructure("); 14044 14045 initialization.append(getVectorConstructor(0 /* column */, 4)); 14046 initialization.append(" , "); 14047 initialization.append(getVectorConstructor(1 /* column */, 4)); 14048 14049 initialization.append("), "); 14050 14051 initialization.append(getVectorConstructor(2 /* column */, 4)); 14052 14053 initialization.append(")"); 14054 14055 initialization.append(" , "); 14056 14057 initialization.append("{ { "); 14058 14059 initialization.append(getVectorInitializer(0 /* column */, 4)); 14060 initialization.append(", "); 14061 initialization.append(getVectorInitializer(1 /* column */, 4)); 14062 14063 initialization.append(" }, "); 14064 14065 initialization.append(getVectorInitializer(2 /* column */, 4)); 14066 14067 initialization.append(" }"); 14068 14069 if (i + 1 < 2) 14070 { 14071 initialization.append(" , "); 14072 } 14073 } 14074 14075 initialization.append(" }"); 14076 14077 break; 14078 14079 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 14080 initialization = "{ "; 14081 initialization.append("{ "); 14082 initialization.append(getVectorInitializer(0 /* column */, 4)); 14083 initialization.append(", "); 14084 initialization.append("{ "); 14085 initialization.append(getVectorInitializer(1 /* column */, 4)); 14086 initialization.append(", "); 14087 initialization.append(getVectorInitializer(2 /* column */, 4)); 14088 initialization.append(" }"); 14089 initialization.append(" }"); 14090 initialization.append(", "); 14091 initialization.append(getVectorInitializer(3 /* column */, 4)); 14092 initialization.append(" }"); 14093 14094 break; 14095 14096 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 14097 initialization = "StructureWithStructureWithArray("; 14098 initialization.append("StructureWithArray("); 14099 initialization.append(getVectorConstructor(0 /* column */, 4)); 14100 initialization.append(" , vec4[2]( "); 14101 initialization.append(getVectorConstructor(1 /* column */, 4)); 14102 initialization.append(" , "); 14103 initialization.append(getVectorConstructor(2 /* column */, 4)); 14104 initialization.append(" )"); 14105 initialization.append(")"); 14106 initialization.append(" , "); 14107 initialization.append(getVectorConstructor(3 /* column */, 4)); 14108 initialization.append(")"); 14109 14110 break; 14111 14112 default: 14113 TCU_FAIL("Invalid enum"); 14114 break; 14115 } 14116 14117 return initialization; 14118 } 14119 14120 /** Logs description of current test case 14121 * 14122 **/ 14123 void InitializerListTest::logTestCaseName() 14124 { 14125 const testCase& test_case = m_test_cases[m_current_test_case_index]; 14126 14127 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 14128 14129 switch (test_case.m_initializer) 14130 { 14131 case VECTOR: 14132 message << "List. Single vec" << test_case.m_n_rows; 14133 break; 14134 case MATRIX: 14135 message << "List. Single mat" << test_case.m_n_cols << "x" << test_case.m_n_rows; 14136 break; 14137 case MATRIX_ROWS: 14138 message << "Ctr. Single mat" << test_case.m_n_cols << "x" << test_case.m_n_rows; 14139 break; 14140 case STRUCT: 14141 message << "List. Structure"; 14142 break; 14143 case NESTED_STRUCT_CTR: 14144 message << "Ctr. Nested structure"; 14145 break; 14146 case NESTED_STRUCT_LIST: 14147 message << "List. Nested structure"; 14148 break; 14149 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 14150 message << "List. Structure with structure array"; 14151 break; 14152 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 14153 message << "Mix. Structure with structure array"; 14154 break; 14155 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 14156 message << "List. Structure with structure with array"; 14157 break; 14158 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 14159 message << "Mix. Structure with structure with array"; 14160 break; 14161 case ARRAY_SCALAR: 14162 message << "List. Array of scalars"; 14163 break; 14164 case ARRAY_VECTOR_CTR: 14165 message << "Ctr. Array of vec" << test_case.m_n_rows; 14166 break; 14167 case ARRAY_VECTOR_LIST: 14168 message << "List. Array of vec" << test_case.m_n_rows; 14169 break; 14170 case ARRAY_MATRIX_CTR: 14171 message << "Ctr. Array of mat" << test_case.m_n_cols << "x" << test_case.m_n_rows; 14172 break; 14173 case ARRAY_MATRIX_LIST: 14174 message << "List. Array of mat" << test_case.m_n_cols << "x" << test_case.m_n_rows; 14175 break; 14176 case ARRAY_STRUCT: 14177 message << "List. Array of structures"; 14178 break; 14179 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 14180 message << "List. Array of structures with structures"; 14181 break; 14182 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 14183 message << "Mix. Array of structures with structures"; 14184 break; 14185 case UNSIZED_ARRAY_SCALAR: 14186 message << "List. Unsized array of scalars"; 14187 break; 14188 case UNSIZED_ARRAY_VECTOR: 14189 message << "List. Unsized array of vec" << test_case.m_n_rows; 14190 break; 14191 case UNSIZED_ARRAY_MATRIX: 14192 message << "List. Unsized array of mat" << test_case.m_n_cols << "x" << test_case.m_n_rows; 14193 break; 14194 case UNSIZED_ARRAY_STRUCT: 14195 message << "List. Unsized array of structures"; 14196 break; 14197 default: 14198 TCU_FAIL("Invalid enum"); 14199 break; 14200 } 14201 14202 message << tcu::TestLog::EndMessage; 14203 } 14204 14205 /** Get string representing sum for current test case 14206 * 14207 * @return String 14208 **/ 14209 std::string InitializerListTest::getSum() 14210 { 14211 static const GLchar* var = "variable"; 14212 14213 const testCase& test_case = m_test_cases[m_current_test_case_index]; 14214 14215 std::string sum; 14216 14217 switch (test_case.m_initializer) 14218 { 14219 case VECTOR: 14220 sum = getVectorSum(var, test_case.m_n_rows); 14221 14222 break; 14223 14224 case MATRIX: 14225 case MATRIX_ROWS: 14226 sum = getVectorArraySum("variable[INDEX]", test_case.m_n_cols, test_case.m_n_rows); 14227 14228 break; 14229 14230 case STRUCT: 14231 sum = getVectorSum("variable.member_a", test_case.m_n_rows); 14232 sum.append(" + "); 14233 sum.append(getVectorSum("variable.member_b", test_case.m_n_rows)); 14234 14235 break; 14236 14237 case ARRAY_SCALAR: 14238 case UNSIZED_ARRAY_SCALAR: 14239 sum = "variable[0] + variable[1] + variable[2] + variable[3]"; 14240 14241 break; 14242 14243 case ARRAY_VECTOR_LIST: 14244 case ARRAY_VECTOR_CTR: 14245 case UNSIZED_ARRAY_VECTOR: 14246 sum = getVectorArraySum("variable[INDEX]", 4 /* columns */, test_case.m_n_rows); 14247 14248 break; 14249 14250 case ARRAY_MATRIX_LIST: 14251 case ARRAY_MATRIX_CTR: 14252 case UNSIZED_ARRAY_MATRIX: 14253 sum.append(getVectorArraySum("variable[0][INDEX]", test_case.m_n_cols, test_case.m_n_rows)); 14254 sum.append(" + "); 14255 sum.append(getVectorArraySum("variable[1][INDEX]", test_case.m_n_cols, test_case.m_n_rows)); 14256 sum.append(" + "); 14257 sum.append(getVectorArraySum("variable[2][INDEX]", test_case.m_n_cols, test_case.m_n_rows)); 14258 sum.append(" + "); 14259 sum.append(getVectorArraySum("variable[3][INDEX]", test_case.m_n_cols, test_case.m_n_rows)); 14260 14261 break; 14262 14263 case ARRAY_STRUCT: 14264 case UNSIZED_ARRAY_STRUCT: 14265 sum.append(getVectorArraySum("variable[INDEX].member_a", 4, test_case.m_n_rows)); 14266 sum.append(" + "); 14267 sum.append(getVectorArraySum("variable[INDEX].member_b", 4, test_case.m_n_rows)); 14268 14269 break; 14270 14271 case NESTED_STRUCT_CTR: 14272 case NESTED_STRUCT_LIST: 14273 sum.append(getVectorSum("variable.member_a.member_a", 4)); 14274 sum.append(" + "); 14275 sum.append(getVectorSum("variable.member_a.member_b", 4)); 14276 sum.append(" + "); 14277 sum.append(getVectorSum("variable.member_b", 4)); 14278 14279 break; 14280 14281 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 14282 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 14283 sum.append(getVectorSum("variable.member_a", 4)); 14284 sum.append(" + "); 14285 sum.append(getVectorArraySum("variable.member_b[INDEX].member_a", 3, 4)); 14286 sum.append(" + "); 14287 sum.append(getVectorArraySum("variable.member_b[INDEX].member_b", 3, 4)); 14288 14289 break; 14290 14291 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 14292 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 14293 sum.append(getVectorArraySum("variable[INDEX].member_a.member_a", 4, 4)); 14294 sum.append(" + "); 14295 sum.append(getVectorArraySum("variable[INDEX].member_a.member_b", 4, 4)); 14296 sum.append(" + "); 14297 sum.append(getVectorArraySum("variable[INDEX].member_b", 4, 4)); 14298 14299 break; 14300 14301 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 14302 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 14303 sum.append(getVectorSum("variable.member_a.member_a", 4)); 14304 sum.append(" + "); 14305 sum.append(getVectorArraySum("variable.member_a.member_b[INDEX]", 2, 4)); 14306 sum.append(" + "); 14307 sum.append(getVectorSum("variable.member_b", 4)); 14308 14309 break; 14310 14311 default: 14312 TCU_FAIL("Invalid enum"); 14313 break; 14314 } 14315 14316 return sum; 14317 } 14318 14319 /** Get string representing types definition for current test case 14320 * 14321 * @return String 14322 **/ 14323 std::string InitializerListTest::getTypeDefinition() 14324 { 14325 const testCase& test_case = m_test_cases[m_current_test_case_index]; 14326 14327 static const GLchar* basic_struct = "struct BasicStructure {\n" 14328 " vec4 member_a;\n" 14329 " vec4 member_b;\n" 14330 "};\n"; 14331 14332 static const GLchar* struct_with_array = "struct StructureWithArray {\n" 14333 " vec4 member_a;\n" 14334 " vec4 member_b[2];\n" 14335 "};\n"; 14336 14337 static const GLchar* struct_with_struct = "struct StructureWithStructure {\n" 14338 " BasicStructure member_a;\n" 14339 " vec4 member_b;\n" 14340 "};\n"; 14341 14342 static const GLchar* struct_with_struct_array = "struct StructureWithStructArray {\n" 14343 " vec4 member_a;\n" 14344 " BasicStructure member_b[3];\n" 14345 "};\n"; 14346 14347 static const GLchar* struct_with_struct_with_array = "struct StructureWithStructureWithArray {\n" 14348 " StructureWithArray member_a;\n" 14349 " vec4 member_b;\n" 14350 "};\n"; 14351 14352 std::string type_definition; 14353 14354 switch (test_case.m_initializer) 14355 { 14356 case VECTOR: 14357 case MATRIX: 14358 case MATRIX_ROWS: 14359 case ARRAY_SCALAR: 14360 case ARRAY_VECTOR_CTR: 14361 case ARRAY_VECTOR_LIST: 14362 case ARRAY_MATRIX_CTR: 14363 case ARRAY_MATRIX_LIST: 14364 case UNSIZED_ARRAY_SCALAR: 14365 case UNSIZED_ARRAY_VECTOR: 14366 case UNSIZED_ARRAY_MATRIX: 14367 type_definition = ""; 14368 break; 14369 case STRUCT: 14370 case ARRAY_STRUCT: 14371 case UNSIZED_ARRAY_STRUCT: 14372 type_definition = basic_struct; 14373 break; 14374 case NESTED_STRUCT_CTR: 14375 case NESTED_STRUCT_LIST: 14376 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 14377 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 14378 type_definition = basic_struct; 14379 type_definition.append(struct_with_struct); 14380 break; 14381 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 14382 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 14383 type_definition = basic_struct; 14384 type_definition.append(struct_with_struct_array); 14385 break; 14386 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 14387 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 14388 type_definition = struct_with_array; 14389 type_definition.append(struct_with_struct_with_array); 14390 break; 14391 default: 14392 TCU_FAIL("Invalid enum"); 14393 break; 14394 } 14395 14396 return type_definition; 14397 } 14398 14399 /** Get string representing name of variable's type for current test case 14400 * 14401 * @return String 14402 **/ 14403 std::string InitializerListTest::getTypeName() 14404 { 14405 const testCase& test_case = m_test_cases[m_current_test_case_index]; 14406 14407 static const GLchar* basic_struct = "BasicStructure"; 14408 14409 static const GLchar* struct_with_struct = "StructureWithStructure"; 14410 14411 static const GLchar* struct_with_struct_array = "StructureWithStructArray"; 14412 14413 static const GLchar* struct_with_struct_with_array = "StructureWithStructureWithArray"; 14414 14415 std::string type_name; 14416 14417 switch (test_case.m_initializer) 14418 { 14419 case VECTOR: 14420 case MATRIX: 14421 case MATRIX_ROWS: 14422 case ARRAY_VECTOR_CTR: 14423 case ARRAY_VECTOR_LIST: 14424 case ARRAY_MATRIX_CTR: 14425 case ARRAY_MATRIX_LIST: 14426 case UNSIZED_ARRAY_VECTOR: 14427 case UNSIZED_ARRAY_MATRIX: 14428 type_name = Utils::getTypeName(Utils::FLOAT, test_case.m_n_cols, test_case.m_n_rows); 14429 break; 14430 case STRUCT: 14431 case ARRAY_STRUCT: 14432 case UNSIZED_ARRAY_STRUCT: 14433 type_name = basic_struct; 14434 break; 14435 case NESTED_STRUCT_CTR: 14436 case NESTED_STRUCT_LIST: 14437 case NESTED_ARRAY_STRUCT_STRUCT_LIST: 14438 case NESTED_ARRAY_STRUCT_STRUCT_MIX: 14439 type_name = struct_with_struct; 14440 break; 14441 case NESTED_STURCT_ARRAYS_STRUCT_LIST: 14442 case NESTED_STURCT_ARRAYS_STRUCT_MIX: 14443 type_name = struct_with_struct_array; 14444 break; 14445 case NESTED_STRUCT_STRUCT_ARRAY_LIST: 14446 case NESTED_STRUCT_STRUCT_ARRAY_MIX: 14447 type_name = struct_with_struct_with_array; 14448 break; 14449 case ARRAY_SCALAR: 14450 case UNSIZED_ARRAY_SCALAR: 14451 type_name = "float"; 14452 break; 14453 default: 14454 TCU_FAIL("Invalid enum"); 14455 break; 14456 } 14457 14458 return type_name; 14459 } 14460 14461 /** Get string representing array of vector constructors 14462 * 14463 * @param columns Number of columns 14464 * @param size Size of vector 14465 * 14466 * @return String 14467 **/ 14468 std::string InitializerListTest::getVectorArrayCtr(GLuint columns, GLuint size) 14469 { 14470 std::string result; 14471 14472 for (GLuint col = 0; col < columns; ++col) 14473 { 14474 result.append(getVectorConstructor(col, size)); 14475 14476 if (col + 1 < columns) 14477 { 14478 result.append(", "); 14479 } 14480 } 14481 14482 return result; 14483 } 14484 14485 /** Get string representing array of vector initializers 14486 * 14487 * @param columns Number of columns 14488 * @param size Size of vector 14489 * 14490 * @return String 14491 **/ 14492 std::string InitializerListTest::getVectorArrayList(GLuint columns, GLuint size) 14493 { 14494 std::string result; 14495 14496 for (GLuint col = 0; col < columns; ++col) 14497 { 14498 result.append(getVectorInitializer(col, size)); 14499 14500 if (col + 1 < columns) 14501 { 14502 result.append(", "); 14503 } 14504 } 14505 14506 return result; 14507 } 14508 14509 /** Get string representing vector constructor 14510 * 14511 * @param column Index of column of uni_matrix to use as data source 14512 * @param size Size of vector 14513 * 14514 * @return String 14515 **/ 14516 std::string InitializerListTest::getVectorConstructor(GLuint column, GLuint size) 14517 { 14518 const std::string& type_name = Utils::getTypeName(Utils::FLOAT, 1 /*n_cols*/, size); 14519 14520 std::string result; 14521 14522 result.append(type_name); 14523 result.append("("); 14524 result.append(getVectorValues(column, size)); 14525 result.append(")"); 14526 14527 return result; 14528 } 14529 14530 /** Get string representing vector initializer 14531 * 14532 * @param column Index of column of uni_matrix to use as data source 14533 * @param size Size of vector 14534 * 14535 * @return String 14536 **/ 14537 std::string InitializerListTest::getVectorInitializer(GLuint column, GLuint size) 14538 { 14539 std::string result; 14540 14541 result.append("{"); 14542 result.append(getVectorValues(column, size)); 14543 result.append("}"); 14544 14545 return result; 14546 } 14547 14548 /** Get string representing sum of vector array. Token INDEX in name will be replaced with element index. 14549 * 14550 * @param array_name Name of array variable 14551 * @param columns Number of columns to sum 14552 * @param size Size of vector 14553 * 14554 * @return String 14555 **/ 14556 std::string InitializerListTest::getVectorArraySum(const GLchar* array_name, GLuint columns, GLuint size) 14557 { 14558 static const GLchar* lut[] = { "0", "1", "2", "3" }; 14559 14560 std::string sum; 14561 14562 for (GLuint i = 0; i < columns; ++i) 14563 { 14564 size_t position = 0; 14565 std::string name = array_name; 14566 14567 Utils::replaceToken("INDEX", position, lut[i], name); 14568 14569 sum.append(getVectorSum(name.c_str(), size)); 14570 14571 if (i + 1 < columns) 14572 { 14573 sum.append(" + "); 14574 } 14575 } 14576 14577 return sum; 14578 } 14579 14580 /** Get string representing sum of vectors' elements 14581 * 14582 * @param vector_name Name of vector variable 14583 * @param size Size of vector 14584 * 14585 * @return String 14586 **/ 14587 std::string InitializerListTest::getVectorSum(const GLchar* vector_name, GLuint size) 14588 { 14589 static const GLchar* lut[] = { 14590 ".x", ".y", ".z", ".w", 14591 }; 14592 14593 std::string sum; 14594 14595 for (GLuint i = 0; i < size; ++i) 14596 { 14597 sum.append(vector_name); 14598 sum.append(lut[i]); 14599 14600 if (i + 1 < size) 14601 { 14602 sum.append(" + "); 14603 } 14604 } 14605 14606 return sum; 14607 } 14608 14609 /** Get string representing vector values 14610 * 14611 * @param column Index of column of uni_matrix to use as data source 14612 * @param size Size of vector 14613 * 14614 * @return String 14615 **/ 14616 std::string InitializerListTest::getVectorValues(GLuint column, GLuint size) 14617 { 14618 const GLchar* init_template = 0; 14619 const GLchar* column_index = 0; 14620 14621 switch (size) 14622 { 14623 case 2: 14624 init_template = "uni_matrix[COLUMN].x, uni_matrix[COLUMN].y"; 14625 break; 14626 case 3: 14627 init_template = "uni_matrix[COLUMN].x, uni_matrix[COLUMN].y, uni_matrix[COLUMN].z"; 14628 break; 14629 case 4: 14630 init_template = "uni_matrix[COLUMN].z, uni_matrix[COLUMN].y, uni_matrix[COLUMN].z, uni_matrix[COLUMN].w"; 14631 break; 14632 } 14633 14634 switch (column) 14635 { 14636 case 0: 14637 column_index = "0"; 14638 break; 14639 case 1: 14640 column_index = "1"; 14641 break; 14642 case 2: 14643 column_index = "2"; 14644 break; 14645 case 3: 14646 column_index = "3"; 14647 break; 14648 } 14649 14650 std::string initializer = init_template; 14651 14652 Utils::replaceAllTokens("COLUMN", column_index, initializer); 14653 14654 return initializer; 14655 } 14656 14657 /** Constructor 14658 * 14659 * @param context Test context 14660 **/ 14661 InitializerListNegativeTest::InitializerListNegativeTest(deqp::Context& context) 14662 : NegativeTestBase(context, "initializer_list_negative", "Verifies invalid initializers") 14663 { 14664 /* Nothing to be done here */ 14665 } 14666 14667 /** Set up next test case 14668 * 14669 * @param test_case_index Index of next test case 14670 * 14671 * @return false if there is no more test cases, true otherwise 14672 **/ 14673 bool InitializerListNegativeTest::prepareNextTestCase(glw::GLuint test_case_index) 14674 { 14675 m_current_test_case_index = test_case_index; 14676 14677 if ((glw::GLuint)-1 == test_case_index) 14678 { 14679 m_current_test_case_index = 0; 14680 return true; 14681 } 14682 else if (m_test_cases.size() <= test_case_index) 14683 { 14684 return false; 14685 } 14686 14687 logTestCaseName(); 14688 14689 return true; 14690 } 14691 14692 /** Prepare source for given shader stage 14693 * 14694 * @param in_stage Shader stage, compute shader will use 430 14695 * @param in_use_version_400 Select if 400 or 420 should be used 14696 * @param out_source Prepared shader source instance 14697 **/ 14698 void InitializerListNegativeTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 14699 Utils::shaderSource& out_source) 14700 { 14701 static const GLchar* verification_snippet = " TYPE_NAME variable = INITIALIZATION;\n" 14702 "\n" 14703 " float sum = SUM;\n" 14704 "\n" 14705 " if (0 != sum)\n" 14706 " {\n" 14707 " result = vec4(1, 0, 0, 1);\n" 14708 " }\n"; 14709 14710 static const GLchar* compute_shader_template = 14711 "VERSION\n" 14712 "\n" 14713 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 14714 "\n" 14715 "writeonly uniform image2D uni_image;\n" 14716 "\n" 14717 "TYPE_DEFINITION\n" 14718 "\n" 14719 "void main()\n" 14720 "{\n" 14721 " vec4 result = vec4(0, 1, 0, 1);\n" 14722 "\n" 14723 "VERIFICATION" 14724 "\n" 14725 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 14726 "}\n" 14727 "\n"; 14728 14729 static const GLchar* fragment_shader_template = "VERSION\n" 14730 "\n" 14731 "in vec4 gs_fs_result;\n" 14732 "out vec4 fs_out_result;\n" 14733 "\n" 14734 "TYPE_DEFINITION\n" 14735 "\n" 14736 "void main()\n" 14737 "{\n" 14738 " vec4 result = vec4(0, 1, 0, 1);\n" 14739 "\n" 14740 "VERIFICATION" 14741 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 14742 " {\n" 14743 " result = vec4(1, 0, 0, 1);\n" 14744 " }\n" 14745 "\n" 14746 " fs_out_result = result;\n" 14747 "}\n" 14748 "\n"; 14749 14750 static const GLchar* geometry_shader_template = "VERSION\n" 14751 "\n" 14752 "layout(points) in;\n" 14753 "layout(triangle_strip, max_vertices = 4) out;\n" 14754 "\n" 14755 "in vec4 tes_gs_result[];\n" 14756 "out vec4 gs_fs_result;\n" 14757 "\n" 14758 "TYPE_DEFINITION\n" 14759 "\n" 14760 "void main()\n" 14761 "{\n" 14762 " vec4 result = vec4(0, 1, 0, 1);\n" 14763 "\n" 14764 "VERIFICATION" 14765 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 14766 " {\n" 14767 " result = vec4(1, 0, 0, 1);\n" 14768 " }\n" 14769 "\n" 14770 " gs_fs_result = result;\n" 14771 " gl_Position = vec4(-1, -1, 0, 1);\n" 14772 " EmitVertex();\n" 14773 " gs_fs_result = result;\n" 14774 " gl_Position = vec4(-1, 1, 0, 1);\n" 14775 " EmitVertex();\n" 14776 " gs_fs_result = result;\n" 14777 " gl_Position = vec4(1, -1, 0, 1);\n" 14778 " EmitVertex();\n" 14779 " gs_fs_result = result;\n" 14780 " gl_Position = vec4(1, 1, 0, 1);\n" 14781 " EmitVertex();\n" 14782 "}\n" 14783 "\n"; 14784 14785 static const GLchar* tess_ctrl_shader_template = 14786 "VERSION\n" 14787 "\n" 14788 "layout(vertices = 1) out;\n" 14789 "\n" 14790 "in vec4 vs_tcs_result[];\n" 14791 "out vec4 tcs_tes_result[];\n" 14792 "\n" 14793 "TYPE_DEFINITION\n" 14794 "\n" 14795 "void main()\n" 14796 "{\n" 14797 " vec4 result = vec4(0, 1, 0, 1);\n" 14798 "\n" 14799 "VERIFICATION" 14800 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 14801 " {\n" 14802 " result = vec4(1, 0, 0, 1);\n" 14803 " }\n" 14804 "\n" 14805 " tcs_tes_result[gl_InvocationID] = result;\n" 14806 "\n" 14807 " gl_TessLevelOuter[0] = 1.0;\n" 14808 " gl_TessLevelOuter[1] = 1.0;\n" 14809 " gl_TessLevelOuter[2] = 1.0;\n" 14810 " gl_TessLevelOuter[3] = 1.0;\n" 14811 " gl_TessLevelInner[0] = 1.0;\n" 14812 " gl_TessLevelInner[1] = 1.0;\n" 14813 "}\n" 14814 "\n"; 14815 14816 static const GLchar* tess_eval_shader_template = "VERSION\n" 14817 "\n" 14818 "layout(isolines, point_mode) in;\n" 14819 "\n" 14820 "in vec4 tcs_tes_result[];\n" 14821 "out vec4 tes_gs_result;\n" 14822 "\n" 14823 "TYPE_DEFINITION\n" 14824 "\n" 14825 "void main()\n" 14826 "{\n" 14827 " vec4 result = vec4(0, 1, 0, 1);\n" 14828 "\n" 14829 "VERIFICATION" 14830 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 14831 " {\n" 14832 " result = vec4(1, 0, 0, 1);\n" 14833 " }\n" 14834 "\n" 14835 " tes_gs_result = result;\n" 14836 "}\n" 14837 "\n"; 14838 14839 static const GLchar* vertex_shader_template = "VERSION\n" 14840 "\n" 14841 "out vec4 vs_tcs_result;\n" 14842 "\n" 14843 "TYPE_DEFINITION\n" 14844 "\n" 14845 "void main()\n" 14846 "{\n" 14847 " vec4 result = vec4(0, 1, 0, 1);\n" 14848 "\n" 14849 "VERIFICATION" 14850 "\n" 14851 " vs_tcs_result = result;\n" 14852 "}\n" 14853 "\n"; 14854 14855 const std::string& initialization = getInitialization(); 14856 const GLchar* shader_template = 0; 14857 const std::string& sum = getSum(); 14858 const std::string& type_definition = getTypeDefinition(); 14859 const std::string& type_name = getTypeName(); 14860 14861 switch (in_stage) 14862 { 14863 case Utils::COMPUTE_SHADER: 14864 shader_template = compute_shader_template; 14865 break; 14866 case Utils::FRAGMENT_SHADER: 14867 shader_template = fragment_shader_template; 14868 break; 14869 case Utils::GEOMETRY_SHADER: 14870 shader_template = geometry_shader_template; 14871 break; 14872 case Utils::TESS_CTRL_SHADER: 14873 shader_template = tess_ctrl_shader_template; 14874 break; 14875 case Utils::TESS_EVAL_SHADER: 14876 shader_template = tess_eval_shader_template; 14877 break; 14878 case Utils::VERTEX_SHADER: 14879 shader_template = vertex_shader_template; 14880 break; 14881 default: 14882 TCU_FAIL("Invalid enum"); 14883 break; 14884 } 14885 14886 out_source.m_parts[0].m_code = shader_template; 14887 14888 size_t position = 0; 14889 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 14890 out_source.m_parts[0].m_code); 14891 14892 Utils::replaceToken("TYPE_DEFINITION", position, type_definition.c_str(), out_source.m_parts[0].m_code); 14893 14894 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 14895 14896 position -= strlen(verification_snippet); 14897 14898 Utils::replaceToken("TYPE_NAME", position, type_name.c_str(), out_source.m_parts[0].m_code); 14899 14900 Utils::replaceToken("INITIALIZATION", position, initialization.c_str(), out_source.m_parts[0].m_code); 14901 14902 Utils::replaceToken("SUM", position, sum.c_str(), out_source.m_parts[0].m_code); 14903 } 14904 14905 /** Prepare test cases 14906 * 14907 * @return true 14908 **/ 14909 bool InitializerListNegativeTest::testInit() 14910 { 14911 for (GLuint i = 0; i < TESTED_ERRORS_MAX; ++i) 14912 { 14913 const TESTED_ERRORS error = (TESTED_ERRORS)i; 14914 14915 m_test_cases.push_back(error); 14916 } 14917 14918 return true; 14919 } 14920 14921 /** Get string representing initialization list for current test case 14922 * 14923 * @return String 14924 **/ 14925 std::string InitializerListNegativeTest::getInitialization() 14926 { 14927 const TESTED_ERRORS& error = m_test_cases[m_current_test_case_index]; 14928 14929 std::string initialization; 14930 14931 switch (error) 14932 { 14933 case TYPE_UIVEC_BOOL: 14934 initialization = "{ true, 0, 1, 2 }"; 14935 14936 break; 14937 14938 case TYPE_IVEC_BOOL: 14939 initialization = "{ true, 0, -1, 2 }"; 14940 14941 break; 14942 14943 case TYPE_VEC_BOOL: 14944 initialization = "{ true, 0.125, 0.25, 0.375 }"; 14945 14946 break; 14947 14948 case TYPE_MAT_BOOL: 14949 initialization = "{ {false, 0, 1, 1}, {0, 1, 0, 1}, {1, 0, 1, 0}, {0, 1, 0, 1} }"; 14950 14951 break; 14952 14953 case COMPONENTS_VEC_LESS: 14954 case COMPONENTS_VEC_MORE: 14955 initialization = "{ 0, 0.25, 0.375 }"; 14956 14957 break; 14958 14959 case COMPONENTS_MAT_LESS_ROWS: 14960 initialization = "{ {0, 0, 1, 1}, {0, 0, 1}, {1, 0, 1, 0}, {0, 1, 0, 1} }"; 14961 14962 break; 14963 14964 case COMPONENTS_MAT_MORE_ROWS: 14965 initialization = "{ {0, 0, 1}, {0, 0, 1}, {1, 0, 1, 0}, {1, 0, 1} }"; 14966 14967 break; 14968 14969 case COMPONENTS_MAT_LESS_COLUMNS: 14970 initialization = "{ {0, 0, 1, 1}, {1, 0, 1, 0}, {0, 1, 0, 1} }"; 14971 14972 break; 14973 14974 case COMPONENTS_MAT_MORE_COLUMNS: 14975 initialization = "{ {0, 0, 1}, {0, 0, 1}, {1, 0, 1}, {1, 0, 1} }"; 14976 14977 break; 14978 14979 case LIST_IN_CONSTRUCTOR: 14980 initialization = "Struct( { vec4(0, 1, 0, 1), vec3(0, 1, 0) }, vec4(1, 0, 1, 0) )"; 14981 14982 break; 14983 14984 case STRUCT_LAYOUT_MEMBER_TYPE: 14985 initialization = "{ { {0, 1, 0, 1}, vec4(0, 1, 0, 1) }, vec4(1, 0, 1, 0) }"; 14986 14987 break; 14988 14989 case STRUCT_LAYOUT_MEMBER_COUNT_MORE: 14990 initialization = "{ { {0, 1, 0, 1}, vec3(0, 1, 0) } , vec4(1, 0, 1, 0), vec4(1, 0, 1, 0) }"; 14991 14992 break; 14993 14994 case STRUCT_LAYOUT_MEMBER_COUNT_LESS: 14995 initialization = "{ { {0, 1, 0, 1}, vec3(0, 1, 0) } }"; 14996 14997 break; 14998 14999 case STRUCT_LAYOUT_MEMBER_ORDER: 15000 initialization = "{ vec4(1, 0, 1, 0), { vec3(0, 1, 0) , {0, 1, 0, 1} } }"; 15001 15002 break; 15003 15004 default: 15005 TCU_FAIL("Invalid enum"); 15006 break; 15007 } 15008 15009 return initialization; 15010 } 15011 15012 /** Logs description of current test case 15013 * 15014 **/ 15015 void InitializerListNegativeTest::logTestCaseName() 15016 { 15017 const TESTED_ERRORS& error = m_test_cases[m_current_test_case_index]; 15018 15019 tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; 15020 15021 switch (error) 15022 { 15023 case TYPE_UIVEC_BOOL: 15024 message << "Wrong type in uvec initializer list"; 15025 break; 15026 case TYPE_IVEC_BOOL: 15027 message << "Wrong type in ivec initializer list"; 15028 break; 15029 case TYPE_VEC_BOOL: 15030 message << "Wrong type in vec initializer list"; 15031 break; 15032 case TYPE_MAT_BOOL: 15033 message << "Wrong type in mat initializer list"; 15034 break; 15035 case COMPONENTS_VEC_LESS: 15036 message << "Wrong number of componenets in vec initialize list - less"; 15037 break; 15038 case COMPONENTS_VEC_MORE: 15039 message << "Wrong number of componenets in vec initialize list - more"; 15040 break; 15041 case COMPONENTS_MAT_LESS_ROWS: 15042 message << "Wrong number of componenets in mat initialize list - less rows"; 15043 break; 15044 case COMPONENTS_MAT_LESS_COLUMNS: 15045 message << "Wrong number of componenets in mat initialize list - less columns"; 15046 break; 15047 case COMPONENTS_MAT_MORE_ROWS: 15048 message << "Wrong number of componenets in mat initialize list - more rows"; 15049 break; 15050 case COMPONENTS_MAT_MORE_COLUMNS: 15051 message << "Wrong number of componenets in mat initialize list - more columns"; 15052 break; 15053 case LIST_IN_CONSTRUCTOR: 15054 message << "Initializer list in constructor"; 15055 break; 15056 case STRUCT_LAYOUT_MEMBER_TYPE: 15057 message << "Wrong type of structure member"; 15058 break; 15059 case STRUCT_LAYOUT_MEMBER_COUNT_MORE: 15060 message << "Wrong number of structure members - more"; 15061 break; 15062 case STRUCT_LAYOUT_MEMBER_COUNT_LESS: 15063 message << "Wrong number of structure members - less"; 15064 break; 15065 case STRUCT_LAYOUT_MEMBER_ORDER: 15066 message << "Wrong order of structure members"; 15067 break; 15068 default: 15069 TCU_FAIL("Invalid enum"); 15070 break; 15071 } 15072 15073 message << tcu::TestLog::EndMessage; 15074 } 15075 15076 /** Get string representing sum for current test case 15077 * 15078 * @return String 15079 **/ 15080 std::string InitializerListNegativeTest::getSum() 15081 { 15082 const TESTED_ERRORS& error = m_test_cases[m_current_test_case_index]; 15083 15084 std::string sum; 15085 15086 switch (error) 15087 { 15088 case TYPE_UIVEC_BOOL: 15089 case TYPE_IVEC_BOOL: 15090 case TYPE_VEC_BOOL: 15091 case COMPONENTS_VEC_LESS: 15092 sum = "variable.x + variable.y + variable.z + variable.w"; 15093 break; 15094 case TYPE_MAT_BOOL: 15095 case COMPONENTS_MAT_LESS_ROWS: 15096 case COMPONENTS_MAT_LESS_COLUMNS: 15097 sum = "variable[0].x + variable[0].y + variable[0].z + variable[0].w + " 15098 "variable[1].x + variable[1].y + variable[1].z + variable[1].w + " 15099 "variable[2].x + variable[2].y + variable[2].z + variable[2].w + " 15100 "variable[3].x + variable[3].y + variable[3].z + variable[3].w"; 15101 break; 15102 case COMPONENTS_VEC_MORE: 15103 sum = "variable.x + variable.y + variable.z"; 15104 break; 15105 case COMPONENTS_MAT_MORE_ROWS: 15106 case COMPONENTS_MAT_MORE_COLUMNS: 15107 sum = "variable[0].x + variable[0].y + variable[0].z" 15108 "variable[1].x + variable[1].y + variable[1].z" 15109 "variable[2].x + variable[2].y + variable[2].z"; 15110 break; 15111 case LIST_IN_CONSTRUCTOR: 15112 case STRUCT_LAYOUT_MEMBER_TYPE: 15113 case STRUCT_LAYOUT_MEMBER_COUNT_MORE: 15114 case STRUCT_LAYOUT_MEMBER_COUNT_LESS: 15115 case STRUCT_LAYOUT_MEMBER_ORDER: 15116 sum = "variable.member_a.member_a.x + variable.member_a.member_a.y + variable.member_a.member_a.z + " 15117 "variable.member_a.member_a.w + " 15118 "variable.member_a.member_b.x + variable.member_a.member_b.y + variable.member_a.member_b.z + " 15119 "variable.member_b.x + variable.member_b.y + variable.member_b.z + variable.member_b.w"; 15120 break; 15121 default: 15122 TCU_FAIL("Invalid enum"); 15123 break; 15124 } 15125 15126 return sum; 15127 } 15128 15129 /** Get string representing types definition for current test case 15130 * 15131 * @return String 15132 **/ 15133 std::string InitializerListNegativeTest::getTypeDefinition() 15134 { 15135 const TESTED_ERRORS& error = m_test_cases[m_current_test_case_index]; 15136 15137 static const GLchar* struct_def = "struct BasicStructure {\n" 15138 " vec4 member_a;\n" 15139 " vec3 member_b;\n" 15140 "};\n" 15141 "\n" 15142 "struct StructureWithStructure {\n" 15143 " BasicStructure member_a;\n" 15144 " vec4 member_b;\n" 15145 "};\n"; 15146 15147 std::string type_definition; 15148 15149 switch (error) 15150 { 15151 case TYPE_UIVEC_BOOL: 15152 case TYPE_IVEC_BOOL: 15153 case TYPE_VEC_BOOL: 15154 case TYPE_MAT_BOOL: 15155 case COMPONENTS_VEC_LESS: 15156 case COMPONENTS_VEC_MORE: 15157 case COMPONENTS_MAT_LESS_ROWS: 15158 case COMPONENTS_MAT_LESS_COLUMNS: 15159 case COMPONENTS_MAT_MORE_ROWS: 15160 case COMPONENTS_MAT_MORE_COLUMNS: 15161 type_definition = ""; 15162 break; 15163 case LIST_IN_CONSTRUCTOR: 15164 case STRUCT_LAYOUT_MEMBER_TYPE: 15165 case STRUCT_LAYOUT_MEMBER_COUNT_MORE: 15166 case STRUCT_LAYOUT_MEMBER_COUNT_LESS: 15167 case STRUCT_LAYOUT_MEMBER_ORDER: 15168 type_definition = struct_def; 15169 break; 15170 default: 15171 TCU_FAIL("Invalid enum"); 15172 break; 15173 } 15174 15175 return type_definition; 15176 } 15177 15178 /** Get string representing name of variable's type for current test case 15179 * 15180 * @return String 15181 **/ 15182 std::string InitializerListNegativeTest::getTypeName() 15183 { 15184 const TESTED_ERRORS& error = m_test_cases[m_current_test_case_index]; 15185 15186 static const GLchar* struct_with_struct = "StructureWithStructure"; 15187 15188 std::string type_name; 15189 15190 switch (error) 15191 { 15192 case TYPE_UIVEC_BOOL: 15193 type_name = "uvec4"; 15194 break; 15195 case TYPE_IVEC_BOOL: 15196 type_name = "ivec4"; 15197 break; 15198 case TYPE_VEC_BOOL: 15199 case COMPONENTS_VEC_LESS: 15200 type_name = "vec4"; 15201 break; 15202 case COMPONENTS_VEC_MORE: 15203 type_name = "vec2"; 15204 break; 15205 case TYPE_MAT_BOOL: 15206 case COMPONENTS_MAT_LESS_ROWS: 15207 case COMPONENTS_MAT_LESS_COLUMNS: 15208 type_name = "mat4"; 15209 break; 15210 case COMPONENTS_MAT_MORE_ROWS: 15211 case COMPONENTS_MAT_MORE_COLUMNS: 15212 type_name = "mat3"; 15213 break; 15214 break; 15215 case LIST_IN_CONSTRUCTOR: 15216 case STRUCT_LAYOUT_MEMBER_TYPE: 15217 case STRUCT_LAYOUT_MEMBER_COUNT_MORE: 15218 case STRUCT_LAYOUT_MEMBER_COUNT_LESS: 15219 case STRUCT_LAYOUT_MEMBER_ORDER: 15220 type_name = struct_with_struct; 15221 break; 15222 default: 15223 TCU_FAIL("Invalid enum"); 15224 break; 15225 } 15226 15227 return type_name; 15228 } 15229 15230 /** Constructor 15231 * 15232 * @param context Test context 15233 **/ 15234 LengthOfVectorAndMatrixTest::LengthOfVectorAndMatrixTest(deqp::Context& context) 15235 : GLSLTestBase(context, "length_of_vector_and_matrix", "Test verifies .length() for vectors and matrices") 15236 { 15237 /* Nothing to be done here */ 15238 } 15239 15240 /** Set up next test case 15241 * 15242 * @param test_case_index Index of next test case 15243 * 15244 * @return false if there is no more test cases, true otherwise 15245 **/ 15246 bool LengthOfVectorAndMatrixTest::prepareNextTestCase(glw::GLuint test_case_index) 15247 { 15248 m_current_test_case_index = test_case_index; 15249 15250 if ((glw::GLuint)-1 == test_case_index) 15251 { 15252 m_current_test_case_index = 0; 15253 return true; 15254 } 15255 else if (m_test_cases.size() <= test_case_index) 15256 { 15257 return false; 15258 } 15259 15260 const testCase& test_case = m_test_cases[m_current_test_case_index]; 15261 15262 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Tested type: " 15263 << Utils::getTypeName(test_case.m_type, test_case.m_n_cols, test_case.m_n_rows) 15264 << tcu::TestLog::EndMessage; 15265 15266 return true; 15267 } 15268 15269 /** Prepare source for given shader stage 15270 * 15271 * @param in_stage Shader stage, compute shader will use 430 15272 * @param in_use_version_400 Select if 400 or 420 should be used 15273 * @param out_source Prepared shader source instance 15274 **/ 15275 void LengthOfVectorAndMatrixTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 15276 Utils::shaderSource& out_source) 15277 { 15278 if (Utils::COMPUTE_SHADER == in_stage) 15279 { 15280 m_is_compute_program = true; 15281 prepareComputeShaderSource(out_source); 15282 } 15283 else 15284 { 15285 m_is_compute_program = false; 15286 prepareDrawShaderSource(in_stage, in_use_version_400, out_source); 15287 } 15288 } 15289 15290 /** Overwritte of prepareUniforms method 15291 * 15292 * @param program Current program 15293 **/ 15294 void LengthOfVectorAndMatrixTest::prepareUniforms(Utils::program& program) 15295 { 15296 static const GLfloat float_value = 0.125; 15297 static const GLint int_value = -1; 15298 static const GLuint uint_value = 1; 15299 15300 static const GLfloat float_data[16] = { float_value, float_value, float_value, float_value, 15301 float_value, float_value, float_value, float_value, 15302 float_value, float_value, float_value, float_value, 15303 float_value, float_value, float_value, float_value }; 15304 15305 static const GLint int_data[4] = { int_value, int_value, int_value, int_value }; 15306 15307 static const GLuint uint_data[4] = { uint_value, uint_value, uint_value, uint_value }; 15308 15309 if (false == m_is_compute_program) 15310 { 15311 return; 15312 } 15313 15314 const testCase& test_case = m_test_cases[m_current_test_case_index]; 15315 15316 switch (test_case.m_type) 15317 { 15318 case Utils::FLOAT: 15319 program.uniform("uni_variable", Utils::FLOAT, test_case.m_n_cols, test_case.m_n_rows, float_data); 15320 break; 15321 case Utils::INT: 15322 program.uniform("uni_variable", Utils::INT, 1 /* columns */, test_case.m_n_rows, int_data); 15323 break; 15324 case Utils::UINT: 15325 program.uniform("uni_variable", Utils::UINT, 1 /* columns */, test_case.m_n_rows, uint_data); 15326 break; 15327 default: 15328 TCU_FAIL("Invalid enum"); 15329 } 15330 } 15331 15332 /** Prepare vertex buffer 15333 * 15334 * @param program Program object 15335 * @param buffer Vertex buffer 15336 * @param vao Vertex array object 15337 * 15338 * @return 0 15339 **/ 15340 void LengthOfVectorAndMatrixTest::prepareVertexBuffer(const Utils::program& program, Utils::buffer& buffer, 15341 Utils::vertexArray& vao) 15342 { 15343 static const GLfloat float_value = 0.125f; 15344 static const GLint int_value = -1; 15345 static const GLuint uint_value = 1; 15346 15347 static const GLfloat float_data[16] = { float_value, float_value, float_value, float_value, 15348 float_value, float_value, float_value, float_value, 15349 float_value, float_value, float_value, float_value, 15350 float_value, float_value, float_value, float_value }; 15351 15352 static const GLint int_data[4] = { int_value, int_value, int_value, int_value }; 15353 15354 static const GLuint uint_data[4] = { uint_value, uint_value, uint_value, uint_value }; 15355 15356 const testCase& test_case = m_test_cases[m_current_test_case_index]; 15357 15358 std::string variable_name = Utils::getVariableName(Utils::VERTEX_SHADER, Utils::INPUT, "variable"); 15359 GLint variable_loc = program.getAttribLocation(variable_name.c_str()); 15360 15361 if (-1 == variable_loc) 15362 { 15363 TCU_FAIL("Vertex attribute location is invalid"); 15364 } 15365 15366 vao.generate(); 15367 vao.bind(); 15368 15369 buffer.generate(GL_ARRAY_BUFFER); 15370 15371 GLvoid* data_ptr = 0; 15372 GLsizeiptr data_size = 0; 15373 15374 switch (test_case.m_type) 15375 { 15376 case Utils::FLOAT: 15377 data_ptr = (GLvoid*)float_data; 15378 data_size = sizeof(float_data); 15379 break; 15380 case Utils::INT: 15381 data_ptr = (GLvoid*)int_data; 15382 data_size = sizeof(int_data); 15383 break; 15384 case Utils::UINT: 15385 data_ptr = (GLvoid*)uint_data; 15386 data_size = sizeof(uint_data); 15387 break; 15388 default: 15389 TCU_FAIL("Invalid enum"); 15390 } 15391 15392 buffer.update(data_size, data_ptr, GL_STATIC_DRAW); 15393 15394 /* GL entry points */ 15395 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 15396 15397 /* Set up vao */ 15398 switch (test_case.m_type) 15399 { 15400 case Utils::FLOAT: 15401 for (GLuint col = 0; col < test_case.m_n_cols; ++col) 15402 { 15403 const GLuint index = variable_loc + col; 15404 const GLint size = test_case.m_n_rows; 15405 const GLvoid* offset = (const GLvoid*)(test_case.m_n_rows * sizeof(GLfloat) * col); 15406 15407 gl.vertexAttribPointer(index, size, GL_FLOAT /* type */, GL_FALSE /* normalized*/, 0, offset); 15408 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer"); 15409 } 15410 break; 15411 case Utils::INT: 15412 gl.vertexAttribIPointer(variable_loc, test_case.m_n_rows /* size */, GL_INT /* type */, 0 /* stride */, 15413 0 /* offset */); 15414 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribIPointer"); 15415 break; 15416 case Utils::UINT: 15417 gl.vertexAttribIPointer(variable_loc, test_case.m_n_rows /* size */, GL_UNSIGNED_INT /* type */, 0 /* stride */, 15418 0 /* offset */); 15419 GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribIPointer"); 15420 break; 15421 default: 15422 DE_ASSERT(0); 15423 break; 15424 } 15425 15426 /* Enable attribute */ 15427 for (GLuint col = 0; col < test_case.m_n_cols; ++col) 15428 { 15429 gl.enableVertexAttribArray(variable_loc + col); 15430 GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray"); 15431 } 15432 } 15433 15434 /** Prepare test cases 15435 * 15436 * @return true 15437 **/ 15438 bool LengthOfVectorAndMatrixTest::testInit() 15439 { 15440 /* Vectors */ 15441 for (GLuint row = 2; row <= 4; ++row) 15442 { 15443 testCase test_case = { Utils::UINT, 1 /* n_cols */, row }; 15444 15445 m_test_cases.push_back(test_case); 15446 } 15447 15448 for (GLuint row = 2; row <= 4; ++row) 15449 { 15450 testCase test_case = { Utils::INT, 1 /* n_cols */, row }; 15451 15452 m_test_cases.push_back(test_case); 15453 } 15454 15455 for (GLuint row = 2; row <= 4; ++row) 15456 { 15457 testCase test_case = { Utils::FLOAT, 1 /* n_cols */, row }; 15458 15459 m_test_cases.push_back(test_case); 15460 } 15461 15462 /* Matrices */ 15463 for (GLuint col = 2; col <= 4; ++col) 15464 { 15465 for (GLuint row = 2; row <= 4; ++row) 15466 { 15467 testCase test_case = { Utils::FLOAT, col, row }; 15468 15469 m_test_cases.push_back(test_case); 15470 } 15471 } 15472 15473 return true; 15474 } 15475 15476 /** Get string representing value that should be placed at token EXPECTED_VALUE 15477 * 15478 * @param in_stage Shader stage 15479 * 15480 * @return String with value 15481 **/ 15482 std::string LengthOfVectorAndMatrixTest::getExpectedValue(Utils::SHADER_STAGES in_stage) 15483 { 15484 const testCase& test_case = m_test_cases[m_current_test_case_index]; 15485 15486 GLuint count = 0; 15487 15488 switch (in_stage) 15489 { 15490 case Utils::FRAGMENT_SHADER: 15491 count = 3; 15492 break; 15493 case Utils::COMPUTE_SHADER: 15494 count = 2; 15495 break; 15496 default: 15497 count = 4; 15498 } 15499 15500 if (1 == test_case.m_n_cols) 15501 { 15502 count *= test_case.m_n_rows; 15503 } 15504 else 15505 { 15506 count *= test_case.m_n_cols; 15507 } 15508 15509 std::string expected_value; 15510 expected_value.resize(64, 0); 15511 15512 switch (test_case.m_type) 15513 { 15514 case Utils::FLOAT: 15515 { 15516 GLfloat value = 0.125f * (GLfloat)count; 15517 sprintf(&expected_value[0], "%f", value); 15518 } 15519 break; 15520 case Utils::INT: 15521 { 15522 GLint value = -1 * (GLint)count; 15523 sprintf(&expected_value[0], "%d", value); 15524 } 15525 break; 15526 case Utils::UINT: 15527 { 15528 GLuint value = 1 * (GLuint)count; 15529 sprintf(&expected_value[0], "%d", value); 15530 } 15531 break; 15532 default: 15533 DE_ASSERT(0); 15534 break; 15535 } 15536 15537 return expected_value; 15538 } 15539 15540 /** Get string reresenting initialization of local variables for current test case 15541 * 15542 * @return String with initialization 15543 **/ 15544 std::string LengthOfVectorAndMatrixTest::getInitialization() 15545 { 15546 const testCase& test_case = m_test_cases[m_current_test_case_index]; 15547 15548 std::string initialization; 15549 15550 if (1 == test_case.m_n_cols) 15551 { 15552 initialization = getVectorInitializer(test_case.m_type, test_case.m_n_rows); 15553 } 15554 else 15555 { 15556 initialization = getMatrixInitializer(test_case.m_n_cols, test_case.m_n_rows); 15557 } 15558 15559 return initialization; 15560 } 15561 15562 /** Get string reresenting initialization of local matrix variables 15563 * 15564 * @param n_cols Number of columns 15565 * @param n_rows Number of rows 15566 * 15567 * @return String with initialization 15568 **/ 15569 std::string LengthOfVectorAndMatrixTest::getMatrixInitializer(GLuint n_cols, GLuint n_rows) 15570 { 15571 std::string result; 15572 15573 result.append("{ "); 15574 15575 for (GLuint col = 0; col < n_cols; ++col) 15576 { 15577 result.append(getVectorInitializer(Utils::FLOAT, n_rows)); 15578 15579 if (col + 1 < n_cols) 15580 { 15581 result.append(", "); 15582 } 15583 } 15584 15585 result.append(" }"); 15586 15587 return result; 15588 } 15589 15590 /** Get string reresenting initialization of local vector variables 15591 * 15592 * @param type Basic type of vector 15593 * @param n_rows Number of rows 15594 * 15595 * @return String with initialization 15596 **/ 15597 std::string LengthOfVectorAndMatrixTest::getVectorInitializer(Utils::TYPES type, glw::GLuint n_rows) 15598 { 15599 std::string result; 15600 const GLchar* value = 0; 15601 15602 switch (type) 15603 { 15604 case Utils::FLOAT: 15605 value = "0.125"; 15606 break; 15607 case Utils::UINT: 15608 value = "1"; 15609 break; 15610 case Utils::INT: 15611 value = "-1"; 15612 break; 15613 default: 15614 TCU_FAIL("Invalid enum"); 15615 } 15616 15617 result.append("{"); 15618 15619 for (GLuint row = 0; row < n_rows; ++row) 15620 { 15621 result.append(value); 15622 15623 if (row + 1 < n_rows) 15624 { 15625 result.append(", "); 15626 } 15627 } 15628 15629 result.append("}"); 15630 15631 return result; 15632 } 15633 15634 /** Prepare source for given shader stage 15635 * 15636 * @param in_stage Shader stage, compute shader will use 430 15637 * @param in_use_version_400 Select if 400 or 420 should be used 15638 * @param out_source Prepared shader source instance 15639 **/ 15640 void LengthOfVectorAndMatrixTest::prepareDrawShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 15641 Utils::shaderSource& out_source) 15642 { 15643 static const GLchar* verification_snippet = 15644 " VARIABLE_TYPE variable = INITIALIZATION;\n" 15645 " Structure structure = { { 0, 1, 0, 1 } , INITIALIZATION };\n" 15646 "\n" 15647 " const uint variable_length = variable.length();\n" 15648 " const uint structure_member_b_length = structure.member_b.length();\n" 15649 " const uint input_member_length = INPUT_VARIABLE_NAME.length();\n" 15650 "#ifndef FRAGMENT\n" 15651 " const uint output_member_length = OUTPUT_VARIABLE_NAME.length();\n" 15652 "#endif // FRAGMENT\n" 15653 "\n" 15654 " BASE_TYPE array_var[variable.length()];\n" 15655 " BASE_TYPE array_str[structure.member_b.length()];\n" 15656 " BASE_TYPE array_in [INPUT_VARIABLE_NAME.length()];\n" 15657 "#ifndef FRAGMENT\n" 15658 " BASE_TYPE array_out[OUTPUT_VARIABLE_NAME.length()];\n" 15659 "#endif // FRAGMENT\n" 15660 "\n" 15661 " BASE_TYPE sum = 0;\n" 15662 "\n" 15663 " for (uint i = 0; i < variable_length; ++i)\n" 15664 " {\n" 15665 " array_var[i] = variableARRAY_INDEX.x;\n" 15666 " }\n" 15667 "\n" 15668 " for (uint i = 0; i < structure_member_b_length; ++i)\n" 15669 " {\n" 15670 " array_str[i] = structure.member_bARRAY_INDEX.y;\n" 15671 " }\n" 15672 "\n" 15673 " for (uint i = 0; i < input_member_length; ++i)\n" 15674 " {\n" 15675 " array_in[i] = INPUT_VARIABLE_NAMEARRAY_INDEX.x;\n" 15676 " }\n" 15677 "\n" 15678 "#ifndef FRAGMENT\n" 15679 " for (uint i = 0; i < output_member_length; ++i)\n" 15680 " {\n" 15681 " array_out[i] = INPUT_VARIABLE_NAMEARRAY_INDEX.y;\n" 15682 " }\n" 15683 "#endif // FRAGMENT\n" 15684 "\n" 15685 " for (uint i = 0; i < array_var.length(); ++i)\n" 15686 " {\n" 15687 " sum += array_var[i];\n" 15688 " }\n" 15689 "\n" 15690 " for (uint i = 0; i < array_str.length(); ++i)\n" 15691 " {\n" 15692 " sum += array_str[i];\n" 15693 " }\n" 15694 "\n" 15695 " for (uint i = 0; i < array_in.length(); ++i)\n" 15696 " {\n" 15697 " sum += array_in[i];\n" 15698 " }\n" 15699 "\n" 15700 "#ifndef FRAGMENT\n" 15701 " for (uint i = 0; i < array_out.length(); ++i)\n" 15702 " {\n" 15703 " sum += array_out[i];\n" 15704 " }\n" 15705 "#endif // FRAGMENT\n" 15706 "\n" 15707 " if (EXPECTED_VALUE != sum)\n" 15708 " {\n" 15709 " result = vec4(1, 0, 0, 1);\n" 15710 " }\n"; 15711 15712 static const GLchar* fragment_shader_template = "VERSION\n" 15713 "\n" 15714 "#define FRAGMENT\n" 15715 "\n" 15716 "in vec4 gs_fs_result;\n" 15717 "out vec4 fs_out_result;\n" 15718 "\n" 15719 "in GSOutputBlock {\n" 15720 " VARIABLE_DECLARATION;\n" 15721 "} input_block;\n" 15722 "\n" 15723 "struct Structure {\n" 15724 " vec4 member_a;\n" 15725 " TYPE_NAME member_b;\n" 15726 "};\n" 15727 "\n" 15728 "void main()\n" 15729 "{\n" 15730 " vec4 result = vec4(0, 1, 0, 1);\n" 15731 "\n" 15732 "VERIFICATION" 15733 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 15734 " {\n" 15735 " result = vec4(1, 0, 0, 1);\n" 15736 " }\n" 15737 "\n" 15738 " fs_out_result = result;\n" 15739 "}\n" 15740 "\n"; 15741 15742 static const GLchar* geometry_shader_template = "VERSION\n" 15743 "\n" 15744 "layout(points) in;\n" 15745 "layout(triangle_strip, max_vertices = 4) out;\n" 15746 "\n" 15747 "in vec4 tes_gs_result[];\n" 15748 "out vec4 gs_fs_result;\n" 15749 "\n" 15750 "in TCSOutputBlock {\n" 15751 " VARIABLE_DECLARATION;\n" 15752 "} input_block[];\n" 15753 "out GSOutputBlock {\n" 15754 " VARIABLE_DECLARATION;\n" 15755 "} output_block;\n" 15756 "\n" 15757 "struct Structure {\n" 15758 " vec4 member_a;\n" 15759 " TYPE_NAME member_b;\n" 15760 "};\n" 15761 "\n" 15762 "void main()\n" 15763 "{\n" 15764 " vec4 result = vec4(0, 1, 0, 1);\n" 15765 "\n" 15766 "VERIFICATION" 15767 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 15768 " {\n" 15769 " result = vec4(1, 0, 0, 1);\n" 15770 " }\n" 15771 "\n" 15772 " gs_fs_result = result;\n" 15773 " gl_Position = vec4(-1, -1, 0, 1);\n" 15774 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15775 " EmitVertex();\n" 15776 " gs_fs_result = result;\n" 15777 " gl_Position = vec4(-1, 1, 0, 1);\n" 15778 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15779 " EmitVertex();\n" 15780 " gs_fs_result = result;\n" 15781 " gl_Position = vec4(1, -1, 0, 1);\n" 15782 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15783 " EmitVertex();\n" 15784 " gs_fs_result = result;\n" 15785 " gl_Position = vec4(1, 1, 0, 1);\n" 15786 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15787 " EmitVertex();\n" 15788 "}\n" 15789 "\n"; 15790 15791 static const GLchar* tess_ctrl_shader_template = 15792 "VERSION\n" 15793 "\n" 15794 "layout(vertices = 1) out;\n" 15795 "\n" 15796 "in vec4 vs_tcs_result[];\n" 15797 "out vec4 tcs_tes_result[];\n" 15798 "\n" 15799 "in VSOutputBlock {\n" 15800 " VARIABLE_DECLARATION;\n" 15801 "} input_block[];\n" 15802 "out TCSOutputBlock {\n" 15803 " VARIABLE_DECLARATION;\n" 15804 "} output_block[];\n" 15805 "\n" 15806 "struct Structure {\n" 15807 " vec4 member_a;\n" 15808 " TYPE_NAME member_b;\n" 15809 "};\n" 15810 "\n" 15811 "void main()\n" 15812 "{\n" 15813 " vec4 result = vec4(0, 1, 0, 1);\n" 15814 "\n" 15815 "VERIFICATION" 15816 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 15817 " {\n" 15818 " result = vec4(1, 0, 0, 1);\n" 15819 " }\n" 15820 "\n" 15821 " tcs_tes_result[gl_InvocationID] = result;\n" 15822 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15823 "\n" 15824 " gl_TessLevelOuter[0] = 1.0;\n" 15825 " gl_TessLevelOuter[1] = 1.0;\n" 15826 " gl_TessLevelOuter[2] = 1.0;\n" 15827 " gl_TessLevelOuter[3] = 1.0;\n" 15828 " gl_TessLevelInner[0] = 1.0;\n" 15829 " gl_TessLevelInner[1] = 1.0;\n" 15830 "}\n" 15831 "\n"; 15832 15833 static const GLchar* tess_eval_shader_template = "VERSION\n" 15834 "\n" 15835 "layout(isolines, point_mode) in;\n" 15836 "\n" 15837 "in vec4 tcs_tes_result[];\n" 15838 "out vec4 tes_gs_result;\n" 15839 "\n" 15840 "in TCSOutputBlock {\n" 15841 " VARIABLE_DECLARATION;\n" 15842 "} input_block[];\n" 15843 "out TCSOutputBlock {\n" 15844 " VARIABLE_DECLARATION;\n" 15845 "} output_block;\n" 15846 "\n" 15847 "struct Structure {\n" 15848 " vec4 member_a;\n" 15849 " TYPE_NAME member_b;\n" 15850 "};\n" 15851 "\n" 15852 "void main()\n" 15853 "{\n" 15854 " vec4 result = vec4(0, 1, 0, 1);\n" 15855 "\n" 15856 "VERIFICATION" 15857 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 15858 " {\n" 15859 " result = vec4(1, 0, 0, 1);\n" 15860 " }\n" 15861 "\n" 15862 " tes_gs_result = result;\n" 15863 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15864 "}\n" 15865 "\n"; 15866 15867 static const GLchar* vertex_shader_template = "VERSION\n" 15868 "\n" 15869 "out vec4 vs_tcs_result;\n" 15870 "\n" 15871 "in VARIABLE_DECLARATION;\n" 15872 "out VSOutputBlock {\n" 15873 " VARIABLE_DECLARATION;\n" 15874 "} output_block;\n" 15875 "\n" 15876 "struct Structure {\n" 15877 " vec4 member_a;\n" 15878 " TYPE_NAME member_b;\n" 15879 "};\n" 15880 "\n" 15881 "void main()\n" 15882 "{\n" 15883 " vec4 result = vec4(0, 1, 0, 1);\n" 15884 "\n" 15885 "VERIFICATION" 15886 "\n" 15887 " vs_tcs_result = result;\n" 15888 " OUTPUT_VARIABLE_NAME = INPUT_VARIABLE_NAME;\n" 15889 "}\n" 15890 "\n"; 15891 15892 const GLchar* array_index = ""; 15893 const testCase& test_case = m_test_cases[m_current_test_case_index]; 15894 const GLchar* shader_template = 0; 15895 const GLchar* input_block_name = "input_block"; 15896 const GLchar* output_block_name = "output_block"; 15897 15898 const std::string& base_type_name = Utils::getTypeName(test_case.m_type, 1 /* cols */, 1 /* rows */); 15899 const std::string& expected_value = getExpectedValue(in_stage); 15900 const std::string& initialization = getInitialization(); 15901 const std::string& type_name = Utils::getTypeName(test_case.m_type, test_case.m_n_cols, test_case.m_n_rows); 15902 15903 std::string input_decl; 15904 std::string input_ref; 15905 std::string output_decl; 15906 std::string output_ref; 15907 15908 Utils::qualifierSet in_qualifiers; 15909 Utils::qualifierSet out_qualifiers; 15910 15911 if ((Utils::UINT == test_case.m_type) || (Utils::INT == test_case.m_type)) 15912 { 15913 if (Utils::VERTEX_SHADER != in_stage) 15914 { 15915 in_qualifiers.push_back(Utils::QUAL_FLAT); 15916 } 15917 15918 out_qualifiers.push_back(Utils::QUAL_FLAT); 15919 } 15920 15921 switch (in_stage) 15922 { 15923 case Utils::COMPUTE_SHADER: 15924 shader_template = 0; 15925 break; 15926 case Utils::FRAGMENT_SHADER: 15927 shader_template = fragment_shader_template; 15928 break; 15929 case Utils::GEOMETRY_SHADER: 15930 shader_template = geometry_shader_template; 15931 break; 15932 case Utils::TESS_CTRL_SHADER: 15933 shader_template = tess_ctrl_shader_template; 15934 break; 15935 case Utils::TESS_EVAL_SHADER: 15936 shader_template = tess_eval_shader_template; 15937 break; 15938 case Utils::VERTEX_SHADER: 15939 shader_template = vertex_shader_template; 15940 break; 15941 default: 15942 TCU_FAIL("Invalid enum"); 15943 break; 15944 } 15945 15946 if (Utils::VERTEX_SHADER != in_stage) 15947 { 15948 Utils::prepareBlockVariableStrings(in_stage, Utils::INPUT, in_qualifiers, type_name.c_str(), "variable", 15949 input_block_name, input_decl, input_ref); 15950 } 15951 else 15952 { 15953 Utils::prepareVariableStrings(in_stage, Utils::INPUT, in_qualifiers, type_name.c_str(), "variable", input_decl, 15954 input_ref); 15955 } 15956 if (Utils::FRAGMENT_SHADER != in_stage) 15957 { 15958 Utils::prepareBlockVariableStrings(in_stage, Utils::OUTPUT, out_qualifiers, type_name.c_str(), "variable", 15959 output_block_name, output_decl, output_ref); 15960 } 15961 else 15962 { 15963 Utils::prepareVariableStrings(in_stage, Utils::OUTPUT, out_qualifiers, type_name.c_str(), "variable", 15964 output_decl, output_ref); 15965 } 15966 15967 if (1 != test_case.m_n_cols) 15968 { 15969 array_index = "[i]"; 15970 } 15971 15972 out_source.m_parts[0].m_code = shader_template; 15973 15974 size_t position = 0; 15975 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 15976 out_source.m_parts[0].m_code); 15977 15978 Utils::replaceToken("VARIABLE_DECLARATION", position, input_decl.c_str(), out_source.m_parts[0].m_code); 15979 15980 if (Utils::FRAGMENT_SHADER != in_stage) 15981 { 15982 Utils::replaceToken("VARIABLE_DECLARATION", position, output_decl.c_str(), out_source.m_parts[0].m_code); 15983 } 15984 15985 Utils::replaceToken("TYPE_NAME", position, type_name.c_str(), out_source.m_parts[0].m_code); 15986 15987 size_t temp = position; 15988 15989 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 15990 15991 position = temp; 15992 15993 Utils::replaceToken("VARIABLE_TYPE", position, type_name.c_str(), out_source.m_parts[0].m_code); 15994 15995 Utils::replaceToken("INITIALIZATION", position, initialization.c_str(), out_source.m_parts[0].m_code); 15996 15997 Utils::replaceToken("INITIALIZATION", position, initialization.c_str(), out_source.m_parts[0].m_code); 15998 15999 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16000 16001 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16002 16003 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16004 16005 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16006 16007 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16008 16009 Utils::replaceToken("EXPECTED_VALUE", position, expected_value.c_str(), out_source.m_parts[0].m_code); 16010 16011 Utils::replaceAllTokens("INPUT_VARIABLE_NAME", input_ref.c_str(), out_source.m_parts[0].m_code); 16012 16013 Utils::replaceAllTokens("OUTPUT_VARIABLE_NAME", output_ref.c_str(), out_source.m_parts[0].m_code); 16014 16015 Utils::replaceAllTokens("ARRAY_INDEX", array_index, out_source.m_parts[0].m_code); 16016 } 16017 16018 /** Prepare source for compute shader stage 16019 * 16020 * @param out_source Prepared shader source instance 16021 **/ 16022 void LengthOfVectorAndMatrixTest::prepareComputeShaderSource(Utils::shaderSource& out_source) 16023 { 16024 static const GLchar* verification_snippet = 16025 " VARIABLE_TYPE variable = uni_variable;\n" 16026 " Structure structure = { { 0, 1, 0, 1 } , uni_variable };\n" 16027 "\n" 16028 " const uint variable_length = variable.length();\n" 16029 " const uint structure_member_b_length = structure.member_b.length();\n" 16030 "\n" 16031 " BASE_TYPE array_var[variable.length()];\n" 16032 " BASE_TYPE array_str[structure.member_b.length()];\n" 16033 "\n" 16034 " BASE_TYPE sum = 0;\n" 16035 "\n" 16036 " for (uint i = 0; i < variable_length; ++i)\n" 16037 " {\n" 16038 " array_var[i] = variableARRAY_INDEX.x;\n" 16039 " }\n" 16040 "\n" 16041 " for (uint i = 0; i < structure_member_b_length; ++i)\n" 16042 " {\n" 16043 " array_str[i] = structure.member_bARRAY_INDEX.y;\n" 16044 " }\n" 16045 "\n" 16046 " for (uint i = 0; i < array_var.length(); ++i)\n" 16047 " {\n" 16048 " sum += array_var[i];\n" 16049 " }\n" 16050 "\n" 16051 " for (uint i = 0; i < array_str.length(); ++i)\n" 16052 " {\n" 16053 " sum += array_str[i];\n" 16054 " }\n" 16055 "\n" 16056 " if (EXPECTED_VALUE != sum)\n" 16057 " {\n" 16058 " result = vec4(1, 0, 0, 1);\n" 16059 " }\n"; 16060 16061 static const GLchar* compute_shader_template = 16062 "VERSION\n" 16063 "\n" 16064 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 16065 "\n" 16066 "writeonly uniform image2D uni_image;\n" 16067 " uniform TYPE_NAME uni_variable;\n" 16068 "\n" 16069 "struct Structure {\n" 16070 " vec4 member_a;\n" 16071 " TYPE_NAME member_b;\n" 16072 "};\n" 16073 "\n" 16074 "void main()\n" 16075 "{\n" 16076 " vec4 result = vec4(0, 1, 0, 1);\n" 16077 "\n" 16078 "VERIFICATION" 16079 "\n" 16080 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 16081 "}\n" 16082 "\n"; 16083 16084 const testCase& test_case = m_test_cases[m_current_test_case_index]; 16085 const GLchar* array_index = ""; 16086 16087 const std::string& base_type_name = Utils::getTypeName(test_case.m_type, 1 /* cols */, 1 /* rows */); 16088 const std::string& expected_value = getExpectedValue(Utils::COMPUTE_SHADER); 16089 const std::string& type_name = Utils::getTypeName(test_case.m_type, test_case.m_n_cols, test_case.m_n_rows); 16090 16091 if (1 != test_case.m_n_cols) 16092 { 16093 array_index = "[i]"; 16094 } 16095 16096 out_source.m_parts[0].m_code = compute_shader_template; 16097 16098 size_t position = 0; 16099 Utils::replaceToken("VERSION", position, getVersionString(Utils::COMPUTE_SHADER, false), 16100 out_source.m_parts[0].m_code); 16101 16102 Utils::replaceToken("TYPE_NAME", position, type_name.c_str(), out_source.m_parts[0].m_code); 16103 16104 Utils::replaceToken("TYPE_NAME", position, type_name.c_str(), out_source.m_parts[0].m_code); 16105 16106 size_t temp = position; 16107 16108 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 16109 16110 position = temp; 16111 16112 Utils::replaceToken("VARIABLE_TYPE", position, type_name.c_str(), out_source.m_parts[0].m_code); 16113 16114 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16115 16116 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16117 16118 Utils::replaceToken("BASE_TYPE", position, base_type_name.c_str(), out_source.m_parts[0].m_code); 16119 16120 Utils::replaceToken("ARRAY_INDEX", position, array_index, out_source.m_parts[0].m_code); 16121 16122 Utils::replaceToken("ARRAY_INDEX", position, array_index, out_source.m_parts[0].m_code); 16123 16124 Utils::replaceToken("EXPECTED_VALUE", position, expected_value.c_str(), out_source.m_parts[0].m_code); 16125 } 16126 16127 /** Constructor 16128 * 16129 * @param context Test context 16130 **/ 16131 LengthOfComputeResultTest::LengthOfComputeResultTest(deqp::Context& context) 16132 : GLSLTestBase(context, "length_of_compute_result", "Test verifies .length() for results of computation") 16133 { 16134 /* Nothing to be done here */ 16135 } 16136 16137 /** Prepare source for given shader stage 16138 * 16139 * @param in_stage Shader stage, compute shader will use 430 16140 * @param in_use_version_400 Select if 400 or 420 should be used 16141 * @param out_source Prepared shader source instance 16142 **/ 16143 void LengthOfComputeResultTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 16144 Utils::shaderSource& out_source) 16145 { 16146 static const GLchar* uniforms = "uniform mat2x4 goten;\n" 16147 "uniform uvec4 indices;\n" 16148 "uniform uvec4 expected_lengths;\n" 16149 "uniform mat4x3 gohan;\n" 16150 "uniform vec3 vegeta;\n" 16151 "uniform vec3 trunks;\n" 16152 "uniform uint variable;\n" 16153 "uniform float expected_sum;\n"; 16154 16155 static const GLchar* verification_snippet = 16156 " uint lengths[4];\n" 16157 " float x[(gohan * goten).length()];\n" 16158 " float y[(gohan * goten)[variable - 1].length()];\n" 16159 "\n" 16160 " lengths[indices.x] = gohan[variable].length();\n" 16161 " lengths[indices.y] = (gohan * goten).length();\n" 16162 " lengths[indices.z] = (gohan * goten)[variable].length();\n" 16163 " lengths[indices.w] = (vegeta * trunks).length();\n" 16164 "\n" 16165 " float dot_result = dot(vegeta, trunks);\n" 16166 " mat2x3 mul_result = gohan * goten;\n" 16167 "\n" 16168 "#ifdef TESS_CTRL\n" 16169 " const uint position_length = gl_out[gl_InvocationID].gl_Position.length();\n" 16170 "#endif\n" 16171 "#ifndef COMPUTE\n" 16172 "#ifndef FRAGMENT\n" 16173 "#ifndef TESS_CTRL\n" 16174 " const uint position_length = gl_Position.length();\n" 16175 "#endif /*TESS_CTRL */\n" 16176 "#endif /* FRAGMENT */\n" 16177 "#endif /* COMPUTE */\n" 16178 "#ifdef FRAGMENT\n" 16179 " const uint point_coord_length = gl_PointCoord.length();\n" 16180 " const uint sample_position_length = gl_SamplePosition.length();\n" 16181 "#endif /* FRAGMENT */\n" 16182 " const uint outer_length = outerProduct(vegeta, trunks).length();\n" 16183 "\n" 16184 " for (uint i = 0; i < x.length(); ++i)\n" 16185 " {\n" 16186 " x[i] = mul_result[i].x;\n" 16187 " }\n" 16188 "\n" 16189 " for (uint i = 0; i < y.length(); ++i)\n" 16190 " {\n" 16191 " y[i] = mul_result[0][i];\n" 16192 " }\n" 16193 "\n" 16194 " if ( (expected_lengths.x != lengths[0]) ||\n" 16195 " (expected_lengths.y != lengths[1]) ||\n" 16196 " (expected_lengths.z != lengths[2]) ||\n" 16197 " (expected_lengths.w != lengths[3]) ||\n" 16198 "#ifndef COMPUTE\n" 16199 "#ifndef FRAGMENT\n" 16200 " (4 /* vec4 */ != position_length) ||\n" 16201 "#endif /* FRAGMENT */\n" 16202 "#endif /* COMPUTE */\n" 16203 "#ifdef FRAGMENT\n" 16204 " (2 /* vec2 */ != point_coord_length) ||\n" 16205 " (2 /* vec2 */ != sample_position_length) ||\n" 16206 "#endif /* FRAGMENT */\n" 16207 " (0.5 != dot_result) ||\n" 16208 " (3 /* mat3 */ != outer_length) ||\n" 16209 " (expected_sum != x[variable] + y[variable]) )\n" 16210 " {\n" 16211 " result = vec4(1, 0, 0, 1);\n" 16212 " }\n"; 16213 16214 static const GLchar* compute_shader_template = 16215 "VERSION\n" 16216 "\n" 16217 "#define COMPUTE\n" 16218 "\n" 16219 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 16220 "\n" 16221 "writeonly uniform image2D uni_image;\n" 16222 "\n" 16223 "UNIFORMS" 16224 "\n" 16225 "void main()\n" 16226 "{\n" 16227 " vec4 result = vec4(0, 1, 0, 1);\n" 16228 "\n" 16229 "VERIFICATION" 16230 "\n" 16231 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 16232 "}\n" 16233 "\n"; 16234 16235 static const GLchar* fragment_shader_template = "VERSION\n" 16236 "\n" 16237 "#define FRAGMENT\n" 16238 "\n" 16239 "in vec4 gs_fs_result;\n" 16240 "out vec4 fs_out_result;\n" 16241 "\n" 16242 "UNIFORMS" 16243 "\n" 16244 "void main()\n" 16245 "{\n" 16246 " vec4 result = vec4(0, 1, 0, 1);\n" 16247 "\n" 16248 "VERIFICATION" 16249 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 16250 " {\n" 16251 " result = vec4(1, 0, 0, 1);\n" 16252 " }\n" 16253 "\n" 16254 " fs_out_result = result;\n" 16255 "}\n" 16256 "\n"; 16257 16258 static const GLchar* geometry_shader_template = "VERSION\n" 16259 "\n" 16260 "layout(points) in;\n" 16261 "layout(triangle_strip, max_vertices = 4) out;\n" 16262 "\n" 16263 "in vec4 tes_gs_result[];\n" 16264 "out vec4 gs_fs_result;\n" 16265 "\n" 16266 "UNIFORMS" 16267 "\n" 16268 "void main()\n" 16269 "{\n" 16270 " vec4 result = vec4(0, 1, 0, 1);\n" 16271 "\n" 16272 "VERIFICATION" 16273 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 16274 " {\n" 16275 " result = vec4(1, 0, 0, 1);\n" 16276 " }\n" 16277 "\n" 16278 " gs_fs_result = result;\n" 16279 " gl_Position = vec4(-1, -1, 0, 1);\n" 16280 " EmitVertex();\n" 16281 " gs_fs_result = result;\n" 16282 " gl_Position = vec4(-1, 1, 0, 1);\n" 16283 " EmitVertex();\n" 16284 " gs_fs_result = result;\n" 16285 " gl_Position = vec4(1, -1, 0, 1);\n" 16286 " EmitVertex();\n" 16287 " gs_fs_result = result;\n" 16288 " gl_Position = vec4(1, 1, 0, 1);\n" 16289 " EmitVertex();\n" 16290 "}\n" 16291 "\n"; 16292 16293 static const GLchar* tess_ctrl_shader_template = 16294 "VERSION\n" 16295 "#define TESS_CTRL\n" 16296 "\n" 16297 "layout(vertices = 1) out;\n" 16298 "\n" 16299 "in vec4 vs_tcs_result[];\n" 16300 "out vec4 tcs_tes_result[];\n" 16301 "\n" 16302 "UNIFORMS" 16303 "\n" 16304 "void main()\n" 16305 "{\n" 16306 " vec4 result = vec4(0, 1, 0, 1);\n" 16307 "\n" 16308 "VERIFICATION" 16309 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 16310 " {\n" 16311 " result = vec4(1, 0, 0, 1);\n" 16312 " }\n" 16313 "\n" 16314 " tcs_tes_result[gl_InvocationID] = result;\n" 16315 "\n" 16316 " gl_TessLevelOuter[0] = 1.0;\n" 16317 " gl_TessLevelOuter[1] = 1.0;\n" 16318 " gl_TessLevelOuter[2] = 1.0;\n" 16319 " gl_TessLevelOuter[3] = 1.0;\n" 16320 " gl_TessLevelInner[0] = 1.0;\n" 16321 " gl_TessLevelInner[1] = 1.0;\n" 16322 "}\n" 16323 "\n"; 16324 16325 static const GLchar* tess_eval_shader_template = "VERSION\n" 16326 "\n" 16327 "layout(isolines, point_mode) in;\n" 16328 "\n" 16329 "in vec4 tcs_tes_result[];\n" 16330 "out vec4 tes_gs_result;\n" 16331 "\n" 16332 "UNIFORMS" 16333 "\n" 16334 "void main()\n" 16335 "{\n" 16336 " vec4 result = vec4(0, 1, 0, 1);\n" 16337 "\n" 16338 "VERIFICATION" 16339 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 16340 " {\n" 16341 " result = vec4(1, 0, 0, 1);\n" 16342 " }\n" 16343 "\n" 16344 " tes_gs_result = result;\n" 16345 "}\n" 16346 "\n"; 16347 16348 static const GLchar* vertex_shader_template = "VERSION\n" 16349 "\n" 16350 "out vec4 vs_tcs_result;\n" 16351 "\n" 16352 "UNIFORMS" 16353 "\n" 16354 "void main()\n" 16355 "{\n" 16356 " vec4 result = vec4(0, 1, 0, 1);\n" 16357 "\n" 16358 "VERIFICATION" 16359 "\n" 16360 " vs_tcs_result = result;\n" 16361 "}\n" 16362 "\n"; 16363 16364 const GLchar* shader_template = 0; 16365 16366 switch (in_stage) 16367 { 16368 case Utils::COMPUTE_SHADER: 16369 shader_template = compute_shader_template; 16370 break; 16371 case Utils::FRAGMENT_SHADER: 16372 shader_template = fragment_shader_template; 16373 break; 16374 case Utils::GEOMETRY_SHADER: 16375 shader_template = geometry_shader_template; 16376 break; 16377 case Utils::TESS_CTRL_SHADER: 16378 shader_template = tess_ctrl_shader_template; 16379 break; 16380 case Utils::TESS_EVAL_SHADER: 16381 shader_template = tess_eval_shader_template; 16382 break; 16383 case Utils::VERTEX_SHADER: 16384 shader_template = vertex_shader_template; 16385 break; 16386 default: 16387 TCU_FAIL("Invalid enum"); 16388 break; 16389 } 16390 16391 out_source.m_parts[0].m_code = shader_template; 16392 16393 size_t position = 0; 16394 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 16395 out_source.m_parts[0].m_code); 16396 16397 Utils::replaceToken("UNIFORMS", position, uniforms, out_source.m_parts[0].m_code); 16398 16399 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 16400 } 16401 16402 /** Overwritte of prepareUniforms method 16403 * 16404 * @param program Current program 16405 **/ 16406 void LengthOfComputeResultTest::prepareUniforms(Utils::program& program) 16407 { 16408 static const GLfloat gohan_data[12] = { 0.125f, 0.125f, 0.125f, 0.125f, 0.125f, 0.125f, 16409 0.125f, 0.125f, 0.125f, 0.125f, 0.125f, 0.125f }; 16410 16411 static const GLfloat goten_data[8] = { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }; 16412 16413 static const GLfloat vegeta_data[3] = { 0.5f, 0.5f, 0.0f }; 16414 16415 static const GLfloat trunks_data[3] = { 0.5f, 0.5f, 0.0f }; 16416 16417 static const GLuint indices_data[4] = { 2, 1, 0, 3 }; 16418 16419 static const GLuint variable_data[1] = { 1 }; 16420 16421 static const GLuint expected_lengths_data[4] = { 3, 2, 3, 3 }; 16422 16423 static const GLfloat expected_sum_data[1] = { 1.0f }; 16424 16425 program.uniform("gohan", Utils::FLOAT, 4 /* n_cols */, 3 /* n_rows */, gohan_data); 16426 program.uniform("goten", Utils::FLOAT, 2 /* n_cols */, 4 /* n_rows */, goten_data); 16427 program.uniform("vegeta", Utils::FLOAT, 1 /* n_cols */, 3 /* n_rows */, vegeta_data); 16428 program.uniform("trunks", Utils::FLOAT, 1 /* n_cols */, 3 /* n_rows */, trunks_data); 16429 program.uniform("indices", Utils::UINT, 1 /* n_cols */, 4 /* n_rows */, indices_data); 16430 program.uniform("variable", Utils::UINT, 1 /* n_cols */, 1 /* n_rows */, variable_data); 16431 program.uniform("expected_lengths", Utils::UINT, 1 /* n_cols */, 4 /* n_rows */, expected_lengths_data); 16432 program.uniform("expected_sum", Utils::FLOAT, 1 /* n_cols */, 1 /* n_rows */, expected_sum_data); 16433 } 16434 16435 /** Constructor 16436 * 16437 * @param context Test context 16438 **/ 16439 ScalarSwizzlersTest::ScalarSwizzlersTest(deqp::Context& context) 16440 : GLSLTestBase(context, "scalar_swizzlers", "Verifies that swizzlers can be used on scalars") 16441 { 16442 /* Nothing to be done here */ 16443 } 16444 16445 /** Prepare source for given shader stage 16446 * 16447 * @param in_stage Shader stage, compute shader will use 430 16448 * @param in_use_version_400 Select if 400 or 420 should be used 16449 * @param out_source Prepared shader source instance 16450 **/ 16451 void ScalarSwizzlersTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 16452 Utils::shaderSource& out_source) 16453 { 16454 static const GLchar* uniforms = "uniform float variable;\n" 16455 "uniform vec3 expected_values;\n"; 16456 16457 static const GLchar* literal = "#define LITERAL 0.375\n"; 16458 16459 static const GLchar* structure = "struct Structure {\n" 16460 " vec2 m_xx;\n" 16461 " vec3 m_xxx;\n" 16462 " vec4 m_xxxx;\n" 16463 " vec2 m_nested_xx;\n" 16464 " vec3 m_nested_xxx;\n" 16465 " vec4 m_nested_xxxx;\n" 16466 "};\n"; 16467 16468 static const GLchar* function = "bool check_values(in Structure structure, in float value)\n" 16469 "{\n" 16470 " const vec2 xx = vec2(value, value);\n" 16471 " const vec3 xxx = vec3(value, value, value);\n" 16472 " const vec4 xxxx = vec4(value, value, value, value);\n" 16473 "\n" 16474 " bool result = true;\n" 16475 "\n" 16476 " if ((xx != structure.m_xx) ||\n" 16477 " (xxx != structure.m_xxx) ||\n" 16478 " (xxxx != structure.m_xxxx) ||\n" 16479 " (xx != structure.m_nested_xx) ||\n" 16480 " (xxx != structure.m_nested_xxx) ||\n" 16481 " (xxxx != structure.m_nested_xxxx) )\n" 16482 " {\n" 16483 " result = false;\n" 16484 " }\n" 16485 "\n" 16486 " return result;\n" 16487 "}\n"; 16488 16489 static const GLchar* verification_snippet = 16490 " Structure literal_result;\n" 16491 " Structure constant_result;\n" 16492 " Structure variable_result;\n" 16493 "\n" 16494 " literal_result.m_xx = LITERAL.xx ;\n" 16495 " literal_result.m_xxx = LITERAL.xxx ;\n" 16496 " literal_result.m_xxxx = LITERAL.xxxx;\n" 16497 " literal_result.m_nested_xx = LITERAL.x.rr.sss.rr ;\n" 16498 " literal_result.m_nested_xxx = LITERAL.s.xx.rrr.xxx ;\n" 16499 " literal_result.m_nested_xxxx = LITERAL.r.ss.xxx.ssss;\n" 16500 "\n" 16501 " const float constant = 0.125;\n" 16502 "\n" 16503 " constant_result.m_xx = constant.xx ;\n" 16504 " constant_result.m_xxx = constant.xxx ;\n" 16505 " constant_result.m_xxxx = constant.xxxx;\n" 16506 " constant_result.m_nested_xx = constant.x.rr.sss.rr ;\n" 16507 " constant_result.m_nested_xxx = constant.s.xx.rrr.xxx ;\n" 16508 " constant_result.m_nested_xxxx = constant.r.ss.xxx.ssss;\n" 16509 "\n" 16510 " variable_result.m_xx = variable.xx ;\n" 16511 " variable_result.m_xxx = variable.xxx ;\n" 16512 " variable_result.m_xxxx = variable.xxxx;\n" 16513 " variable_result.m_nested_xx = variable.x.rr.sss.rr ;\n" 16514 " variable_result.m_nested_xxx = variable.s.xx.rrr.xxx ;\n" 16515 " variable_result.m_nested_xxxx = variable.r.ss.xxx.ssss;\n" 16516 "\n" 16517 " if ((false == check_values(literal_result, expected_values.x)) ||\n" 16518 " (false == check_values(constant_result, expected_values.y)) ||\n" 16519 " (false == check_values(variable_result, expected_values.z)) )\n" 16520 " {\n" 16521 " result = vec4(1, 0, 0, 1);\n" 16522 " }\n"; 16523 16524 static const GLchar* compute_shader_template = 16525 "VERSION\n" 16526 "\n" 16527 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 16528 "\n" 16529 "writeonly uniform image2D uni_image;\n" 16530 "\n" 16531 "STRUCTURE" 16532 "\n" 16533 "UNIFORMS" 16534 "\n" 16535 "FUNCTION" 16536 "\n" 16537 "LITERAL" 16538 "\n" 16539 "void main()\n" 16540 "{\n" 16541 " vec4 result = vec4(0, 1, 0, 1);\n" 16542 "\n" 16543 "VERIFICATION" 16544 "\n" 16545 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 16546 "}\n" 16547 "\n"; 16548 16549 static const GLchar* fragment_shader_template = "VERSION\n" 16550 "\n" 16551 "#define FRAGMENT\n" 16552 "\n" 16553 "in vec4 gs_fs_result;\n" 16554 "out vec4 fs_out_result;\n" 16555 "\n" 16556 "STRUCTURE" 16557 "\n" 16558 "UNIFORMS" 16559 "\n" 16560 "FUNCTION" 16561 "\n" 16562 "LITERAL" 16563 "\n" 16564 "void main()\n" 16565 "{\n" 16566 " vec4 result = vec4(0, 1, 0, 1);\n" 16567 "\n" 16568 "VERIFICATION" 16569 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 16570 " {\n" 16571 " result = vec4(1, 0, 0, 1);\n" 16572 " }\n" 16573 "\n" 16574 " fs_out_result = result;\n" 16575 "}\n" 16576 "\n"; 16577 16578 static const GLchar* geometry_shader_template = "VERSION\n" 16579 "\n" 16580 "layout(points) in;\n" 16581 "layout(triangle_strip, max_vertices = 4) out;\n" 16582 "\n" 16583 "in vec4 tes_gs_result[];\n" 16584 "out vec4 gs_fs_result;\n" 16585 "\n" 16586 "STRUCTURE" 16587 "\n" 16588 "UNIFORMS" 16589 "\n" 16590 "FUNCTION" 16591 "\n" 16592 "LITERAL" 16593 "\n" 16594 "void main()\n" 16595 "{\n" 16596 " vec4 result = vec4(0, 1, 0, 1);\n" 16597 "\n" 16598 "VERIFICATION" 16599 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 16600 " {\n" 16601 " result = vec4(1, 0, 0, 1);\n" 16602 " }\n" 16603 "\n" 16604 " gs_fs_result = result;\n" 16605 " gl_Position = vec4(-1, -1, 0, 1);\n" 16606 " EmitVertex();\n" 16607 " gs_fs_result = result;\n" 16608 " gl_Position = vec4(-1, 1, 0, 1);\n" 16609 " EmitVertex();\n" 16610 " gs_fs_result = result;\n" 16611 " gl_Position = vec4(1, -1, 0, 1);\n" 16612 " EmitVertex();\n" 16613 " gs_fs_result = result;\n" 16614 " gl_Position = vec4(1, 1, 0, 1);\n" 16615 " EmitVertex();\n" 16616 "}\n" 16617 "\n"; 16618 16619 static const GLchar* tess_ctrl_shader_template = 16620 "VERSION\n" 16621 "\n" 16622 "layout(vertices = 1) out;\n" 16623 "\n" 16624 "in vec4 vs_tcs_result[];\n" 16625 "out vec4 tcs_tes_result[];\n" 16626 "\n" 16627 "STRUCTURE" 16628 "\n" 16629 "UNIFORMS" 16630 "\n" 16631 "FUNCTION" 16632 "\n" 16633 "LITERAL" 16634 "\n" 16635 "void main()\n" 16636 "{\n" 16637 " vec4 result = vec4(0, 1, 0, 1);\n" 16638 "\n" 16639 "VERIFICATION" 16640 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 16641 " {\n" 16642 " result = vec4(1, 0, 0, 1);\n" 16643 " }\n" 16644 "\n" 16645 " tcs_tes_result[gl_InvocationID] = result;\n" 16646 "\n" 16647 " gl_TessLevelOuter[0] = 1.0;\n" 16648 " gl_TessLevelOuter[1] = 1.0;\n" 16649 " gl_TessLevelOuter[2] = 1.0;\n" 16650 " gl_TessLevelOuter[3] = 1.0;\n" 16651 " gl_TessLevelInner[0] = 1.0;\n" 16652 " gl_TessLevelInner[1] = 1.0;\n" 16653 "}\n" 16654 "\n"; 16655 16656 static const GLchar* tess_eval_shader_template = "VERSION\n" 16657 "\n" 16658 "layout(isolines, point_mode) in;\n" 16659 "\n" 16660 "in vec4 tcs_tes_result[];\n" 16661 "out vec4 tes_gs_result;\n" 16662 "\n" 16663 "STRUCTURE" 16664 "\n" 16665 "UNIFORMS" 16666 "\n" 16667 "FUNCTION" 16668 "\n" 16669 "LITERAL" 16670 "\n" 16671 "void main()\n" 16672 "{\n" 16673 " vec4 result = vec4(0, 1, 0, 1);\n" 16674 "\n" 16675 "VERIFICATION" 16676 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 16677 " {\n" 16678 " result = vec4(1, 0, 0, 1);\n" 16679 " }\n" 16680 "\n" 16681 " tes_gs_result = result;\n" 16682 "}\n" 16683 "\n"; 16684 16685 static const GLchar* vertex_shader_template = "VERSION\n" 16686 "\n" 16687 "out vec4 vs_tcs_result;\n" 16688 "\n" 16689 "STRUCTURE" 16690 "\n" 16691 "UNIFORMS" 16692 "\n" 16693 "FUNCTION" 16694 "\n" 16695 "LITERAL" 16696 "\n" 16697 "void main()\n" 16698 "{\n" 16699 " vec4 result = vec4(0, 1, 0, 1);\n" 16700 "\n" 16701 "VERIFICATION" 16702 "\n" 16703 " vs_tcs_result = result;\n" 16704 "}\n" 16705 "\n"; 16706 16707 const GLchar* shader_template = 0; 16708 16709 switch (in_stage) 16710 { 16711 case Utils::COMPUTE_SHADER: 16712 shader_template = compute_shader_template; 16713 break; 16714 case Utils::FRAGMENT_SHADER: 16715 shader_template = fragment_shader_template; 16716 break; 16717 case Utils::GEOMETRY_SHADER: 16718 shader_template = geometry_shader_template; 16719 break; 16720 case Utils::TESS_CTRL_SHADER: 16721 shader_template = tess_ctrl_shader_template; 16722 break; 16723 case Utils::TESS_EVAL_SHADER: 16724 shader_template = tess_eval_shader_template; 16725 break; 16726 case Utils::VERTEX_SHADER: 16727 shader_template = vertex_shader_template; 16728 break; 16729 default: 16730 TCU_FAIL("Invalid enum"); 16731 break; 16732 } 16733 16734 out_source.m_parts[0].m_code = shader_template; 16735 16736 size_t position = 0; 16737 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 16738 out_source.m_parts[0].m_code); 16739 16740 Utils::replaceToken("STRUCTURE", position, structure, out_source.m_parts[0].m_code); 16741 16742 Utils::replaceToken("UNIFORMS", position, uniforms, out_source.m_parts[0].m_code); 16743 16744 Utils::replaceToken("FUNCTION", position, function, out_source.m_parts[0].m_code); 16745 16746 Utils::replaceToken("LITERAL", position, literal, out_source.m_parts[0].m_code); 16747 16748 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 16749 } 16750 16751 /** Overwritte of prepareUniforms method 16752 * 16753 * @param program Current program 16754 **/ 16755 void ScalarSwizzlersTest::prepareUniforms(Utils::program& program) 16756 { 16757 static const GLfloat variable_data[4] = { 0.75f }; 16758 static const GLfloat expected_values_data[3] = { 0.375f, 0.125f, 0.75f }; 16759 16760 program.uniform("variable", Utils::FLOAT, 1 /* n_cols */, 1 /* n_rows */, variable_data); 16761 program.uniform("expected_values", Utils::FLOAT, 1 /* n_cols */, 3 /* n_rows */, expected_values_data); 16762 } 16763 16764 /** Constructor 16765 * 16766 * @param context Test context 16767 **/ 16768 ScalarSwizzlersInvalidTest::ScalarSwizzlersInvalidTest(deqp::Context& context) 16769 : NegativeTestBase(context, "scalar_swizzlers_invalid", 16770 "Verifies if invalid use of swizzlers on scalars is reported as error") 16771 { 16772 /* Nothing to be done here */ 16773 } 16774 16775 /** Set up next test case 16776 * 16777 * @param test_case_index Index of next test case 16778 * 16779 * @return false if there is no more test cases, true otherwise 16780 **/ 16781 bool ScalarSwizzlersInvalidTest::prepareNextTestCase(glw::GLuint test_case_index) 16782 { 16783 switch (test_case_index) 16784 { 16785 case (glw::GLuint)-1: 16786 case INVALID_Y: 16787 case INVALID_B: 16788 case INVALID_Q: 16789 case INVALID_XY: 16790 case INVALID_XRS: 16791 case WRONG: 16792 case MISSING_PARENTHESIS: 16793 m_case = (TESTED_CASES)test_case_index; 16794 break; 16795 default: 16796 return false; 16797 } 16798 16799 return true; 16800 } 16801 16802 /** Prepare source for given shader stage 16803 * 16804 * @param in_stage Shader stage, compute shader will use 430 16805 * @param in_use_version_400 Select if 400 or 420 should be used 16806 * @param out_source Prepared shader source instance 16807 **/ 16808 void ScalarSwizzlersInvalidTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 16809 Utils::shaderSource& out_source) 16810 { 16811 static const GLchar* uniforms = "uniform float variable;\n"; 16812 16813 static const GLchar* verification_invalid_y = "\n" 16814 " if (0.125 != variable.y) )\n" 16815 " {\n" 16816 " result = vec4(1, 0, 0, 1);\n" 16817 " }\n"; 16818 16819 static const GLchar* verification_invalid_b = "\n" 16820 " if (0.125 != variable.b) )\n" 16821 " {\n" 16822 " result = vec4(1, 0, 0, 1);\n" 16823 " }\n"; 16824 16825 static const GLchar* verification_invalid_q = "\n" 16826 " if (0.125 != variable.q) )\n" 16827 " {\n" 16828 " result = vec4(1, 0, 0, 1);\n" 16829 " }\n"; 16830 16831 static const GLchar* verification_invalid_xy = "\n" 16832 " if (vec2(0.125, 0.25) != variable.xy) )\n" 16833 " {\n" 16834 " result = vec4(1, 0, 0, 1);\n" 16835 " }\n"; 16836 16837 static const GLchar* verification_invalid_xrs = "\n" 16838 " if (vec3(0.125, 0.125, 0.25) != variable.xrs) )\n" 16839 " {\n" 16840 " result = vec4(1, 0, 0, 1);\n" 16841 " }\n"; 16842 16843 static const GLchar* verification_wrong_u = "\n" 16844 " if (0.125 != variable.u) )\n" 16845 " {\n" 16846 " result = vec4(1, 0, 0, 1);\n" 16847 " }\n"; 16848 16849 static const GLchar* verification_missing_parenthesis = "\n" 16850 " if (variable != 1.x) )\n" 16851 " {\n" 16852 " result = vec4(1, 0, 0, 1);\n" 16853 " }\n"; 16854 16855 static const GLchar* compute_shader_template = 16856 "VERSION\n" 16857 "\n" 16858 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 16859 "\n" 16860 "writeonly uniform image2D uni_image;\n" 16861 "\n" 16862 "UNIFORMS" 16863 "\n" 16864 "void main()\n" 16865 "{\n" 16866 " vec4 result = vec4(0, 1, 0, 1);\n" 16867 "\n" 16868 "VERIFICATION" 16869 "\n" 16870 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 16871 "}\n" 16872 "\n"; 16873 16874 static const GLchar* fragment_shader_template = "VERSION\n" 16875 "\n" 16876 "#define FRAGMENT\n" 16877 "\n" 16878 "in vec4 gs_fs_result;\n" 16879 "out vec4 fs_out_result;\n" 16880 "\n" 16881 "UNIFORMS" 16882 "\n" 16883 "void main()\n" 16884 "{\n" 16885 " vec4 result = vec4(0, 1, 0, 1);\n" 16886 "\n" 16887 "VERIFICATION" 16888 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 16889 " {\n" 16890 " result = vec4(1, 0, 0, 1);\n" 16891 " }\n" 16892 "\n" 16893 " fs_out_result = result;\n" 16894 "}\n" 16895 "\n"; 16896 16897 static const GLchar* geometry_shader_template = "VERSION\n" 16898 "\n" 16899 "layout(points) in;\n" 16900 "layout(triangle_strip, max_vertices = 4) out;\n" 16901 "\n" 16902 "in vec4 tes_gs_result[];\n" 16903 "out vec4 gs_fs_result;\n" 16904 "\n" 16905 "UNIFORMS" 16906 "\n" 16907 "void main()\n" 16908 "{\n" 16909 " vec4 result = vec4(0, 1, 0, 1);\n" 16910 "\n" 16911 "VERIFICATION" 16912 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 16913 " {\n" 16914 " result = vec4(1, 0, 0, 1);\n" 16915 " }\n" 16916 "\n" 16917 " gs_fs_result = result;\n" 16918 " gl_Position = vec4(-1, -1, 0, 1);\n" 16919 " EmitVertex();\n" 16920 " gs_fs_result = result;\n" 16921 " gl_Position = vec4(-1, 1, 0, 1);\n" 16922 " EmitVertex();\n" 16923 " gs_fs_result = result;\n" 16924 " gl_Position = vec4(1, -1, 0, 1);\n" 16925 " EmitVertex();\n" 16926 " gs_fs_result = result;\n" 16927 " gl_Position = vec4(1, 1, 0, 1);\n" 16928 " EmitVertex();\n" 16929 "}\n" 16930 "\n"; 16931 16932 static const GLchar* tess_ctrl_shader_template = 16933 "VERSION\n" 16934 "\n" 16935 "layout(vertices = 1) out;\n" 16936 "\n" 16937 "in vec4 vs_tcs_result[];\n" 16938 "out vec4 tcs_tes_result[];\n" 16939 "\n" 16940 "UNIFORMS" 16941 "\n" 16942 "void main()\n" 16943 "{\n" 16944 " vec4 result = vec4(0, 1, 0, 1);\n" 16945 "\n" 16946 "VERIFICATION" 16947 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 16948 " {\n" 16949 " result = vec4(1, 0, 0, 1);\n" 16950 " }\n" 16951 "\n" 16952 " tcs_tes_result[gl_InvocationID] = result;\n" 16953 "\n" 16954 " gl_TessLevelOuter[0] = 1.0;\n" 16955 " gl_TessLevelOuter[1] = 1.0;\n" 16956 " gl_TessLevelOuter[2] = 1.0;\n" 16957 " gl_TessLevelOuter[3] = 1.0;\n" 16958 " gl_TessLevelInner[0] = 1.0;\n" 16959 " gl_TessLevelInner[1] = 1.0;\n" 16960 "}\n" 16961 "\n"; 16962 16963 static const GLchar* tess_eval_shader_template = "VERSION\n" 16964 "\n" 16965 "layout(isolines, point_mode) in;\n" 16966 "\n" 16967 "in vec4 tcs_tes_result[];\n" 16968 "out vec4 tes_gs_result;\n" 16969 "\n" 16970 "UNIFORMS" 16971 "\n" 16972 "void main()\n" 16973 "{\n" 16974 " vec4 result = vec4(0, 1, 0, 1);\n" 16975 "\n" 16976 "VERIFICATION" 16977 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 16978 " {\n" 16979 " result = vec4(1, 0, 0, 1);\n" 16980 " }\n" 16981 "\n" 16982 " tes_gs_result = result;\n" 16983 "}\n" 16984 "\n"; 16985 16986 static const GLchar* vertex_shader_template = "VERSION\n" 16987 "\n" 16988 "out vec4 vs_tcs_result;\n" 16989 "\n" 16990 "UNIFORMS" 16991 "\n" 16992 "void main()\n" 16993 "{\n" 16994 " vec4 result = vec4(0, 1, 0, 1);\n" 16995 "\n" 16996 "VERIFICATION" 16997 "\n" 16998 " vs_tcs_result = result;\n" 16999 "}\n" 17000 "\n"; 17001 17002 const GLchar* shader_template = 0; 17003 const GLchar* verification_snippet = 0; 17004 17005 switch (in_stage) 17006 { 17007 case Utils::COMPUTE_SHADER: 17008 shader_template = compute_shader_template; 17009 break; 17010 case Utils::FRAGMENT_SHADER: 17011 shader_template = fragment_shader_template; 17012 break; 17013 case Utils::GEOMETRY_SHADER: 17014 shader_template = geometry_shader_template; 17015 break; 17016 case Utils::TESS_CTRL_SHADER: 17017 shader_template = tess_ctrl_shader_template; 17018 break; 17019 case Utils::TESS_EVAL_SHADER: 17020 shader_template = tess_eval_shader_template; 17021 break; 17022 case Utils::VERTEX_SHADER: 17023 shader_template = vertex_shader_template; 17024 break; 17025 default: 17026 TCU_FAIL("Invalid enum"); 17027 break; 17028 } 17029 17030 switch (m_case) 17031 { 17032 case INVALID_Y: 17033 verification_snippet = verification_invalid_y; 17034 break; 17035 case INVALID_B: 17036 verification_snippet = verification_invalid_b; 17037 break; 17038 case INVALID_Q: 17039 verification_snippet = verification_invalid_q; 17040 break; 17041 case INVALID_XY: 17042 verification_snippet = verification_invalid_xy; 17043 break; 17044 case INVALID_XRS: 17045 verification_snippet = verification_invalid_xrs; 17046 break; 17047 case WRONG: 17048 verification_snippet = verification_wrong_u; 17049 break; 17050 case MISSING_PARENTHESIS: 17051 verification_snippet = verification_missing_parenthesis; 17052 break; 17053 default: 17054 TCU_FAIL("Invalid enum"); 17055 break; 17056 }; 17057 17058 out_source.m_parts[0].m_code = shader_template; 17059 17060 size_t position = 0; 17061 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 17062 out_source.m_parts[0].m_code); 17063 17064 Utils::replaceToken("UNIFORMS", position, uniforms, out_source.m_parts[0].m_code); 17065 17066 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 17067 } 17068 17069 /* Constants used by BuiltInValuesTest */ 17070 const GLint BuiltInValuesTest::m_min_program_texel_offset_limit = -8; 17071 const GLint BuiltInValuesTest::m_max_program_texel_offset_limit = 7; 17072 17073 /** Constructor 17074 * 17075 * @param context Test context 17076 **/ 17077 BuiltInValuesTest::BuiltInValuesTest(deqp::Context& context) 17078 : GLSLTestBase(context, "built_in_values", "Test verifies values of gl_Min/Max_ProgramTexelOffset") 17079 { 17080 /* Nothing to be done here */ 17081 } 17082 17083 /** Prepare source for given shader stage 17084 * 17085 * @param in_stage Shader stage, compute shader will use 430 17086 * @param in_use_version_400 Select if 400 or 420 should be used 17087 * @param out_source Prepared shader source instance 17088 **/ 17089 void BuiltInValuesTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 17090 Utils::shaderSource& out_source) 17091 { 17092 static const GLchar* verification_snippet = " if ((expected_values.x != gl_MinProgramTexelOffset) ||\n" 17093 " (expected_values.y != gl_MaxProgramTexelOffset) )\n" 17094 " {\n" 17095 " result = vec4(1, 0, 0, 1);\n" 17096 " }\n"; 17097 17098 static const GLchar* compute_shader_template = 17099 "VERSION\n" 17100 "\n" 17101 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 17102 "\n" 17103 "writeonly uniform image2D uni_image;\n" 17104 " uniform ivec2 expected_values;\n" 17105 "\n" 17106 "void main()\n" 17107 "{\n" 17108 " vec4 result = vec4(0, 1, 0, 1);\n" 17109 "\n" 17110 "VERIFICATION" 17111 "\n" 17112 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 17113 "}\n" 17114 "\n"; 17115 17116 static const GLchar* fragment_shader_template = "VERSION\n" 17117 "\n" 17118 "in vec4 gs_fs_result;\n" 17119 "out vec4 fs_out_result;\n" 17120 "\n" 17121 "uniform ivec2 expected_values;\n" 17122 "\n" 17123 "void main()\n" 17124 "{\n" 17125 " vec4 result = vec4(0, 1, 0, 1);\n" 17126 "\n" 17127 "VERIFICATION" 17128 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 17129 " {\n" 17130 " result = vec4(1, 0, 0, 1);\n" 17131 " }\n" 17132 "\n" 17133 " fs_out_result = result;\n" 17134 "}\n" 17135 "\n"; 17136 17137 static const GLchar* geometry_shader_template = "VERSION\n" 17138 "\n" 17139 "layout(points) in;\n" 17140 "layout(triangle_strip, max_vertices = 4) out;\n" 17141 "\n" 17142 "in vec4 tes_gs_result[];\n" 17143 "out vec4 gs_fs_result;\n" 17144 "\n" 17145 "uniform ivec2 expected_values;\n" 17146 "\n" 17147 "void main()\n" 17148 "{\n" 17149 " vec4 result = vec4(0, 1, 0, 1);\n" 17150 "\n" 17151 "VERIFICATION" 17152 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 17153 " {\n" 17154 " result = vec4(1, 0, 0, 1);\n" 17155 " }\n" 17156 "\n" 17157 " gs_fs_result = result;\n" 17158 " gl_Position = vec4(-1, -1, 0, 1);\n" 17159 " EmitVertex();\n" 17160 " gs_fs_result = result;\n" 17161 " gl_Position = vec4(-1, 1, 0, 1);\n" 17162 " EmitVertex();\n" 17163 " gs_fs_result = result;\n" 17164 " gl_Position = vec4(1, -1, 0, 1);\n" 17165 " EmitVertex();\n" 17166 " gs_fs_result = result;\n" 17167 " gl_Position = vec4(1, 1, 0, 1);\n" 17168 " EmitVertex();\n" 17169 "}\n" 17170 "\n"; 17171 17172 static const GLchar* tess_ctrl_shader_template = 17173 "VERSION\n" 17174 "\n" 17175 "layout(vertices = 1) out;\n" 17176 "\n" 17177 "in vec4 vs_tcs_result[];\n" 17178 "out vec4 tcs_tes_result[];\n" 17179 "\n" 17180 "uniform ivec2 expected_values;\n" 17181 "\n" 17182 "void main()\n" 17183 "{\n" 17184 " vec4 result = vec4(0, 1, 0, 1);\n" 17185 "\n" 17186 "VERIFICATION" 17187 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 17188 " {\n" 17189 " result = vec4(1, 0, 0, 1);\n" 17190 " }\n" 17191 "\n" 17192 " tcs_tes_result[gl_InvocationID] = result;\n" 17193 "\n" 17194 " gl_TessLevelOuter[0] = 1.0;\n" 17195 " gl_TessLevelOuter[1] = 1.0;\n" 17196 " gl_TessLevelOuter[2] = 1.0;\n" 17197 " gl_TessLevelOuter[3] = 1.0;\n" 17198 " gl_TessLevelInner[0] = 1.0;\n" 17199 " gl_TessLevelInner[1] = 1.0;\n" 17200 "}\n" 17201 "\n"; 17202 17203 static const GLchar* tess_eval_shader_template = "VERSION\n" 17204 "\n" 17205 "layout(isolines, point_mode) in;\n" 17206 "\n" 17207 "in vec4 tcs_tes_result[];\n" 17208 "out vec4 tes_gs_result;\n" 17209 "\n" 17210 "uniform ivec2 expected_values;\n" 17211 "\n" 17212 "void main()\n" 17213 "{\n" 17214 " vec4 result = vec4(0, 1, 0, 1);\n" 17215 "\n" 17216 "VERIFICATION" 17217 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 17218 " {\n" 17219 " result = vec4(1, 0, 0, 1);\n" 17220 " }\n" 17221 "\n" 17222 " tes_gs_result = result;\n" 17223 "}\n" 17224 "\n"; 17225 17226 static const GLchar* vertex_shader_template = "VERSION\n" 17227 "\n" 17228 "out vec4 vs_tcs_result;\n" 17229 "\n" 17230 "uniform ivec2 expected_values;\n" 17231 "\n" 17232 "void main()\n" 17233 "{\n" 17234 " vec4 result = vec4(0, 1, 0, 1);\n" 17235 "\n" 17236 "VERIFICATION" 17237 "\n" 17238 " vs_tcs_result = result;\n" 17239 "}\n" 17240 "\n"; 17241 17242 const GLchar* shader_template = 0; 17243 17244 switch (in_stage) 17245 { 17246 case Utils::COMPUTE_SHADER: 17247 shader_template = compute_shader_template; 17248 break; 17249 case Utils::FRAGMENT_SHADER: 17250 shader_template = fragment_shader_template; 17251 break; 17252 case Utils::GEOMETRY_SHADER: 17253 shader_template = geometry_shader_template; 17254 break; 17255 case Utils::TESS_CTRL_SHADER: 17256 shader_template = tess_ctrl_shader_template; 17257 break; 17258 case Utils::TESS_EVAL_SHADER: 17259 shader_template = tess_eval_shader_template; 17260 break; 17261 case Utils::VERTEX_SHADER: 17262 shader_template = vertex_shader_template; 17263 break; 17264 default: 17265 TCU_FAIL("Invalid enum"); 17266 break; 17267 } 17268 17269 out_source.m_parts[0].m_code = shader_template; 17270 17271 size_t position = 0; 17272 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 17273 out_source.m_parts[0].m_code); 17274 17275 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 17276 } 17277 17278 /** Overwritte of prepareUniforms method 17279 * 17280 * @param program Current program 17281 **/ 17282 void BuiltInValuesTest::prepareUniforms(Utils::program& program) 17283 { 17284 const GLint expected_values_data[2] = { m_min_program_texel_offset, m_max_program_texel_offset }; 17285 17286 program.uniform("expected_values", Utils::INT, 1 /* n_cols */, 2 /* n_rows */, expected_values_data); 17287 } 17288 17289 /** Prepare test cases 17290 * 17291 * @return true 17292 **/ 17293 bool BuiltInValuesTest::testInit() 17294 { 17295 const Functions& gl = m_context.getRenderContext().getFunctions(); 17296 17297 gl.getIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &m_min_program_texel_offset); 17298 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 17299 17300 gl.getIntegerv(GL_MAX_PROGRAM_TEXEL_OFFSET, &m_max_program_texel_offset); 17301 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 17302 17303 if ((m_min_program_texel_offset_limit > m_min_program_texel_offset) || 17304 (m_max_program_texel_offset_limit > m_max_program_texel_offset)) 17305 { 17306 m_context.getTestContext().getLog() 17307 << tcu::TestLog::Message << "Invalid GL_PROGRAM_TEXEL_OFFSET values." 17308 << " Min: " << m_min_program_texel_offset << " expected at top: " << m_min_program_texel_offset_limit 17309 << " Max: " << m_min_program_texel_offset << " expected at least: " << m_max_program_texel_offset_limit 17310 << tcu::TestLog::EndMessage; 17311 17312 return false; 17313 } 17314 17315 return true; 17316 } 17317 17318 /** Constructor 17319 * 17320 * @param context Test context 17321 **/ 17322 BuiltInAssignmentTest::BuiltInAssignmentTest(deqp::Context& context) 17323 : NegativeTestBase(context, "built_in_assignment", 17324 "Test verifies that built in gl_Min/MaxProgramTexelOffset cannot be assigned") 17325 { 17326 /* Nothing to be done here */ 17327 } 17328 17329 /** Set up next test case 17330 * 17331 * @param test_case_index Index of next test case 17332 * 17333 * @return false if there is no more test cases, true otherwise 17334 **/ 17335 bool BuiltInAssignmentTest::prepareNextTestCase(glw::GLuint test_case_index) 17336 { 17337 const GLchar* description = 0; 17338 17339 switch (test_case_index) 17340 { 17341 case (glw::GLuint)-1: 17342 case 0: 17343 description = "Testing gl_MinProgramTexelOffset"; 17344 break; 17345 case 1: 17346 description = "Testing gl_MaxProgramTexelOffset"; 17347 break; 17348 default: 17349 return false; 17350 } 17351 17352 m_case = test_case_index; 17353 17354 m_context.getTestContext().getLog() << tcu::TestLog::Message << description << tcu::TestLog::EndMessage; 17355 17356 return true; 17357 } 17358 17359 /** Prepare source for given shader stage 17360 * 17361 * @param in_stage Shader stage, compute shader will use 430 17362 * @param in_use_version_400 Select if 400 or 420 should be used 17363 * @param out_source Prepared shader source instance 17364 **/ 17365 void BuiltInAssignmentTest::prepareShaderSource(Utils::SHADER_STAGES in_stage, bool in_use_version_400, 17366 Utils::shaderSource& out_source) 17367 { 17368 static const GLchar* min_verification_snippet = " gl_MinProgramTexelOffset += gl_MaxProgramTexelOffset\n" 17369 "\n" 17370 " if (expected_value != gl_MinProgramTexelOffset)\n" 17371 " {\n" 17372 " result = vec4(1, 0, 0, 1);\n" 17373 " }\n"; 17374 17375 static const GLchar* max_verification_snippet = " gl_MaxProgramTexelOffset += gl_MinProgramTexelOffset\n" 17376 "\n" 17377 " if (expected_value != gl_MaxProgramTexelOffset)\n" 17378 " {\n" 17379 " result = vec4(1, 0, 0, 1);\n" 17380 " }\n"; 17381 17382 static const GLchar* compute_shader_template = 17383 "VERSION\n" 17384 "\n" 17385 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 17386 "\n" 17387 "writeonly uniform image2D uni_image;\n" 17388 " uniform ivec2 expected_values;\n" 17389 "\n" 17390 "void main()\n" 17391 "{\n" 17392 " vec4 result = vec4(0, 1, 0, 1);\n" 17393 "\n" 17394 "VERIFICATION" 17395 "\n" 17396 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), result);\n" 17397 "}\n" 17398 "\n"; 17399 17400 static const GLchar* fragment_shader_template = "VERSION\n" 17401 "\n" 17402 "in vec4 gs_fs_result;\n" 17403 "out vec4 fs_out_result;\n" 17404 "\n" 17405 "uniform ivec2 expected_values;\n" 17406 "\n" 17407 "void main()\n" 17408 "{\n" 17409 " vec4 result = vec4(0, 1, 0, 1);\n" 17410 "\n" 17411 "VERIFICATION" 17412 " else if (vec4(0, 1, 0, 1) != gs_fs_result)\n" 17413 " {\n" 17414 " result = vec4(1, 0, 0, 1);\n" 17415 " }\n" 17416 "\n" 17417 " fs_out_result = result;\n" 17418 "}\n" 17419 "\n"; 17420 17421 static const GLchar* geometry_shader_template = "VERSION\n" 17422 "\n" 17423 "layout(points) in;\n" 17424 "layout(triangle_strip, max_vertices = 4) out;\n" 17425 "\n" 17426 "in vec4 tes_gs_result[];\n" 17427 "out vec4 gs_fs_result;\n" 17428 "\n" 17429 "uniform ivec2 expected_values;\n" 17430 "\n" 17431 "void main()\n" 17432 "{\n" 17433 " vec4 result = vec4(0, 1, 0, 1);\n" 17434 "\n" 17435 "VERIFICATION" 17436 " else if (vec4(0, 1, 0, 1) != tes_gs_result[0])\n" 17437 " {\n" 17438 " result = vec4(1, 0, 0, 1);\n" 17439 " }\n" 17440 "\n" 17441 " gs_fs_result = result;\n" 17442 " gl_Position = vec4(-1, -1, 0, 1);\n" 17443 " EmitVertex();\n" 17444 " gs_fs_result = result;\n" 17445 " gl_Position = vec4(-1, 1, 0, 1);\n" 17446 " EmitVertex();\n" 17447 " gs_fs_result = result;\n" 17448 " gl_Position = vec4(1, -1, 0, 1);\n" 17449 " EmitVertex();\n" 17450 " gs_fs_result = result;\n" 17451 " gl_Position = vec4(1, 1, 0, 1);\n" 17452 " EmitVertex();\n" 17453 "}\n" 17454 "\n"; 17455 17456 static const GLchar* tess_ctrl_shader_template = 17457 "VERSION\n" 17458 "\n" 17459 "layout(vertices = 1) out;\n" 17460 "\n" 17461 "in vec4 vs_tcs_result[];\n" 17462 "out vec4 tcs_tes_result[];\n" 17463 "\n" 17464 "uniform ivec2 expected_values;\n" 17465 "\n" 17466 "void main()\n" 17467 "{\n" 17468 " vec4 result = vec4(0, 1, 0, 1);\n" 17469 "\n" 17470 "VERIFICATION" 17471 " else if (vec4(0, 1, 0, 1) != vs_tcs_result[gl_InvocationID])\n" 17472 " {\n" 17473 " result = vec4(1, 0, 0, 1);\n" 17474 " }\n" 17475 "\n" 17476 " tcs_tes_result[gl_InvocationID] = result;\n" 17477 "\n" 17478 " gl_TessLevelOuter[0] = 1.0;\n" 17479 " gl_TessLevelOuter[1] = 1.0;\n" 17480 " gl_TessLevelOuter[2] = 1.0;\n" 17481 " gl_TessLevelOuter[3] = 1.0;\n" 17482 " gl_TessLevelInner[0] = 1.0;\n" 17483 " gl_TessLevelInner[1] = 1.0;\n" 17484 "}\n" 17485 "\n"; 17486 17487 static const GLchar* tess_eval_shader_template = "VERSION\n" 17488 "\n" 17489 "layout(isolines, point_mode) in;\n" 17490 "\n" 17491 "in vec4 tcs_tes_result[];\n" 17492 "out vec4 tes_gs_result;\n" 17493 "\n" 17494 "uniform ivec2 expected_values;\n" 17495 "\n" 17496 "void main()\n" 17497 "{\n" 17498 " vec4 result = vec4(0, 1, 0, 1);\n" 17499 "\n" 17500 "VERIFICATION" 17501 " else if (vec4(0, 1, 0, 1) != tcs_tes_result[0])\n" 17502 " {\n" 17503 " result = vec4(1, 0, 0, 1);\n" 17504 " }\n" 17505 "\n" 17506 " tes_gs_result = result;\n" 17507 "}\n" 17508 "\n"; 17509 17510 static const GLchar* vertex_shader_template = "VERSION\n" 17511 "\n" 17512 "out vec4 vs_tcs_result;\n" 17513 "\n" 17514 "uniform ivec2 expected_values;\n" 17515 "\n" 17516 "void main()\n" 17517 "{\n" 17518 " vec4 result = vec4(0, 1, 0, 1);\n" 17519 "\n" 17520 "VERIFICATION" 17521 "\n" 17522 " vs_tcs_result = result;\n" 17523 "}\n" 17524 "\n"; 17525 17526 const GLchar* shader_template = 0; 17527 const GLchar* verification_snippet = 0; 17528 17529 switch (in_stage) 17530 { 17531 case Utils::COMPUTE_SHADER: 17532 shader_template = compute_shader_template; 17533 break; 17534 case Utils::FRAGMENT_SHADER: 17535 shader_template = fragment_shader_template; 17536 break; 17537 case Utils::GEOMETRY_SHADER: 17538 shader_template = geometry_shader_template; 17539 break; 17540 case Utils::TESS_CTRL_SHADER: 17541 shader_template = tess_ctrl_shader_template; 17542 break; 17543 case Utils::TESS_EVAL_SHADER: 17544 shader_template = tess_eval_shader_template; 17545 break; 17546 case Utils::VERTEX_SHADER: 17547 shader_template = vertex_shader_template; 17548 break; 17549 default: 17550 TCU_FAIL("Invalid enum"); 17551 break; 17552 } 17553 17554 switch (m_case) 17555 { 17556 case (glw::GLuint)-1: 17557 case 0: 17558 verification_snippet = min_verification_snippet; 17559 break; 17560 case 1: 17561 verification_snippet = max_verification_snippet; 17562 break; 17563 } 17564 17565 out_source.m_parts[0].m_code = shader_template; 17566 17567 size_t position = 0; 17568 Utils::replaceToken("VERSION", position, getVersionString(in_stage, in_use_version_400), 17569 out_source.m_parts[0].m_code); 17570 17571 Utils::replaceToken("VERIFICATION", position, verification_snippet, out_source.m_parts[0].m_code); 17572 } 17573 17574 /** Constructor. 17575 * 17576 * @param context CTS context. 17577 **/ 17578 Utils::buffer::buffer(deqp::Context& context) : m_id(0), m_context(context), m_target(0) 17579 { 17580 } 17581 17582 /** Destructor 17583 * 17584 **/ 17585 Utils::buffer::~buffer() 17586 { 17587 release(); 17588 } 17589 17590 /** Execute BindBuffer 17591 * 17592 **/ 17593 void Utils::buffer::bind() const 17594 { 17595 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17596 17597 gl.bindBuffer(m_target, m_id); 17598 GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); 17599 } 17600 17601 /** Execute BindBufferRange 17602 * 17603 * @param index <index> parameter 17604 * @param offset <offset> parameter 17605 * @param size <size> parameter 17606 **/ 17607 void Utils::buffer::bindRange(glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size) 17608 { 17609 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17610 17611 gl.bindBufferRange(m_target, index, m_id, offset, size); 17612 GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferRange"); 17613 } 17614 17615 /** Execute GenBuffer 17616 * 17617 * @param target Target that will be used by this buffer 17618 **/ 17619 void Utils::buffer::generate(glw::GLenum target) 17620 { 17621 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17622 17623 m_target = target; 17624 17625 gl.genBuffers(1, &m_id); 17626 GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers"); 17627 } 17628 17629 /** Maps buffer content 17630 * 17631 * @param access Access rights for mapped region 17632 * 17633 * @return Mapped memory 17634 **/ 17635 void* Utils::buffer::map(GLenum access) const 17636 { 17637 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17638 17639 gl.bindBuffer(m_target, m_id); 17640 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer"); 17641 17642 void* result = gl.mapBuffer(m_target, access); 17643 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); 17644 17645 return result; 17646 } 17647 17648 /** Unmaps buffer 17649 * 17650 **/ 17651 void Utils::buffer::unmap() const 17652 { 17653 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17654 17655 gl.bindBuffer(m_target, m_id); 17656 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer"); 17657 17658 gl.unmapBuffer(m_target); 17659 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 17660 } 17661 17662 /** Execute BufferData 17663 * 17664 * @param size <size> parameter 17665 * @param data <data> parameter 17666 * @param usage <usage> parameter 17667 **/ 17668 void Utils::buffer::update(glw::GLsizeiptr size, glw::GLvoid* data, glw::GLenum usage) 17669 { 17670 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17671 17672 gl.bindBuffer(m_target, m_id); 17673 GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer"); 17674 17675 gl.bufferData(m_target, size, data, usage); 17676 GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData"); 17677 } 17678 17679 /** Release buffer 17680 * 17681 **/ 17682 void Utils::buffer::release() 17683 { 17684 if (0 != m_id) 17685 { 17686 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17687 17688 gl.deleteBuffers(1, &m_id); 17689 m_id = 0; 17690 } 17691 } 17692 17693 /** Constructor 17694 * 17695 * @param context CTS context 17696 **/ 17697 Utils::framebuffer::framebuffer(deqp::Context& context) : m_id(0), m_context(context) 17698 { 17699 /* Nothing to be done here */ 17700 } 17701 17702 /** Destructor 17703 * 17704 **/ 17705 Utils::framebuffer::~framebuffer() 17706 { 17707 if (0 != m_id) 17708 { 17709 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17710 17711 gl.deleteFramebuffers(1, &m_id); 17712 m_id = 0; 17713 } 17714 } 17715 17716 /** Attach texture to specified attachment 17717 * 17718 * @param attachment Attachment 17719 * @param texture_id Texture id 17720 * @param width Texture width 17721 * @param height Texture height 17722 **/ 17723 void Utils::framebuffer::attachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width, 17724 glw::GLuint height) 17725 { 17726 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17727 17728 bind(); 17729 17730 gl.bindTexture(GL_TEXTURE_2D, texture_id); 17731 GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); 17732 17733 gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, GL_TEXTURE_2D, texture_id, 0 /* level */); 17734 GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture2D"); 17735 17736 gl.viewport(0 /* x */, 0 /* y */, width, height); 17737 GLU_EXPECT_NO_ERROR(gl.getError(), "Viewport"); 17738 } 17739 17740 /** Binds framebuffer to DRAW_FRAMEBUFFER 17741 * 17742 **/ 17743 void Utils::framebuffer::bind() 17744 { 17745 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17746 17747 gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_id); 17748 GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer"); 17749 } 17750 17751 /** Clear framebuffer 17752 * 17753 * @param mask <mask> parameter of glClear. Decides which shall be cleared 17754 **/ 17755 void Utils::framebuffer::clear(glw::GLenum mask) 17756 { 17757 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17758 17759 gl.clear(mask); 17760 GLU_EXPECT_NO_ERROR(gl.getError(), "Clear"); 17761 } 17762 17763 /** Specifies clear color 17764 * 17765 * @param red Red channel 17766 * @param green Green channel 17767 * @param blue Blue channel 17768 * @param alpha Alpha channel 17769 **/ 17770 void Utils::framebuffer::clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) 17771 { 17772 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17773 17774 gl.clearColor(red, green, blue, alpha); 17775 GLU_EXPECT_NO_ERROR(gl.getError(), "ClearColor"); 17776 } 17777 17778 /** Generate framebuffer 17779 * 17780 **/ 17781 void Utils::framebuffer::generate() 17782 { 17783 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17784 17785 gl.genFramebuffers(1, &m_id); 17786 GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers"); 17787 } 17788 17789 Utils::shaderSource::shaderSource() 17790 { 17791 } 17792 17793 Utils::shaderSource::shaderSource(const shaderSource& source) : m_parts(source.m_parts) 17794 { 17795 } 17796 17797 Utils::shaderSource::shaderSource(const glw::GLchar* source_code) 17798 { 17799 if (0 != source_code) 17800 { 17801 m_parts.resize(1); 17802 17803 m_parts[0].m_code = source_code; 17804 } 17805 } 17806 17807 Utils::shaderCompilationException::shaderCompilationException(const shaderSource& source, const glw::GLchar* message) 17808 : m_shader_source(source), m_error_message(message) 17809 { 17810 /* Nothing to be done */ 17811 } 17812 17813 const char* Utils::shaderCompilationException::what() const throw() 17814 { 17815 return "Shader compilation failed"; 17816 } 17817 17818 Utils::programLinkageException::programLinkageException(const glw::GLchar* message) : m_error_message(message) 17819 { 17820 /* Nothing to be done */ 17821 } 17822 17823 const char* Utils::programLinkageException::what() const throw() 17824 { 17825 return "Program linking failed"; 17826 } 17827 17828 const glw::GLenum Utils::program::ARB_COMPUTE_SHADER = 0x91B9; 17829 17830 /** Constructor. 17831 * 17832 * @param context CTS context. 17833 **/ 17834 Utils::program::program(deqp::Context& context) 17835 : m_compute_shader_id(0) 17836 , m_fragment_shader_id(0) 17837 , m_geometry_shader_id(0) 17838 , m_program_object_id(0) 17839 , m_tesselation_control_shader_id(0) 17840 , m_tesselation_evaluation_shader_id(0) 17841 , m_vertex_shader_id(0) 17842 , m_context(context) 17843 { 17844 /* Nothing to be done here */ 17845 } 17846 17847 /** Destructor 17848 * 17849 **/ 17850 Utils::program::~program() 17851 { 17852 remove(); 17853 } 17854 17855 /** Build program 17856 * 17857 * @param compute_shader_code Compute shader source code 17858 * @param fragment_shader_code Fragment shader source code 17859 * @param geometry_shader_code Geometry shader source code 17860 * @param tesselation_control_shader_code Tesselation control shader source code 17861 * @param tesselation_evaluation_shader_code Tesselation evaluation shader source code 17862 * @param vertex_shader_code Vertex shader source code 17863 * @param varying_names Array of strings containing names of varyings to be captured with transfrom feedback 17864 * @param n_varying_names Number of varyings to be captured with transfrom feedback 17865 * @param is_separable Selects if monolithis or separable program should be built. Defaults to false 17866 **/ 17867 void Utils::program::build(const glw::GLchar* compute_shader_code, const glw::GLchar* fragment_shader_code, 17868 const glw::GLchar* geometry_shader_code, const glw::GLchar* tesselation_control_shader_code, 17869 const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code, 17870 const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable) 17871 { 17872 const shaderSource compute_shader(compute_shader_code); 17873 const shaderSource fragment_shader(fragment_shader_code); 17874 const shaderSource geometry_shader(geometry_shader_code); 17875 const shaderSource tesselation_control_shader(tesselation_control_shader_code); 17876 const shaderSource tesselation_evaluation_shader(tesselation_evaluation_shader_code); 17877 const shaderSource vertex_shader(vertex_shader_code); 17878 17879 build(compute_shader, fragment_shader, geometry_shader, tesselation_control_shader, tesselation_evaluation_shader, 17880 vertex_shader, varying_names, n_varying_names, is_separable); 17881 } 17882 17883 /** Build program 17884 * 17885 * @param compute_shader_code Compute shader source code 17886 * @param fragment_shader_code Fragment shader source code 17887 * @param geometry_shader_code Geometry shader source code 17888 * @param tesselation_control_shader_code Tesselation control shader source code 17889 * @param tesselation_evaluation_shader_code Tesselation evaluation shader source code 17890 * @param vertex_shader_code Vertex shader source code 17891 * @param varying_names Array of strings containing names of varyings to be captured with transfrom feedback 17892 * @param n_varying_names Number of varyings to be captured with transfrom feedback 17893 * @param is_separable Selects if monolithis or separable program should be built. Defaults to false 17894 **/ 17895 void Utils::program::build(const shaderSource& compute_shader, const shaderSource& fragment_shader, 17896 const shaderSource& geometry_shader, const shaderSource& tesselation_control_shader, 17897 const shaderSource& tesselation_evaluation_shader, const shaderSource& vertex_shader, 17898 const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable) 17899 { 17900 /* GL entry points */ 17901 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17902 17903 /* Create shader objects and compile */ 17904 if (false == compute_shader.m_parts.empty()) 17905 { 17906 m_compute_shader_id = gl.createShader(ARB_COMPUTE_SHADER); 17907 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 17908 17909 compile(m_compute_shader_id, compute_shader); 17910 } 17911 17912 if (false == fragment_shader.m_parts.empty()) 17913 { 17914 m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); 17915 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 17916 17917 compile(m_fragment_shader_id, fragment_shader); 17918 } 17919 17920 if (false == geometry_shader.m_parts.empty()) 17921 { 17922 m_geometry_shader_id = gl.createShader(GL_GEOMETRY_SHADER); 17923 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 17924 17925 compile(m_geometry_shader_id, geometry_shader); 17926 } 17927 17928 if (false == tesselation_control_shader.m_parts.empty()) 17929 { 17930 m_tesselation_control_shader_id = gl.createShader(GL_TESS_CONTROL_SHADER); 17931 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 17932 17933 compile(m_tesselation_control_shader_id, tesselation_control_shader); 17934 } 17935 17936 if (false == tesselation_evaluation_shader.m_parts.empty()) 17937 { 17938 m_tesselation_evaluation_shader_id = gl.createShader(GL_TESS_EVALUATION_SHADER); 17939 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 17940 17941 compile(m_tesselation_evaluation_shader_id, tesselation_evaluation_shader); 17942 } 17943 17944 if (false == vertex_shader.m_parts.empty()) 17945 { 17946 m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); 17947 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); 17948 17949 compile(m_vertex_shader_id, vertex_shader); 17950 } 17951 17952 /* Create program object */ 17953 m_program_object_id = gl.createProgram(); 17954 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); 17955 17956 /* Set up captyured varyings' names */ 17957 if (0 != n_varying_names) 17958 { 17959 gl.transformFeedbackVaryings(m_program_object_id, n_varying_names, varying_names, GL_INTERLEAVED_ATTRIBS); 17960 GLU_EXPECT_NO_ERROR(gl.getError(), "TransformFeedbackVaryings"); 17961 } 17962 17963 /* Set separable parameter */ 17964 if (true == is_separable) 17965 { 17966 gl.programParameteri(m_program_object_id, GL_PROGRAM_SEPARABLE, GL_TRUE); 17967 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramParameteri"); 17968 } 17969 17970 /* Link program */ 17971 link(); 17972 } 17973 17974 void Utils::program::compile(glw::GLuint shader_id, const Utils::shaderSource& source) const 17975 { 17976 /* GL entry points */ 17977 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 17978 17979 /* Compilation status */ 17980 glw::GLint status = GL_FALSE; 17981 17982 /* Source parts and lengths vectors */ 17983 std::vector<const GLchar*> parts; 17984 std::vector<GLint> lengths_vector; 17985 GLint* lengths = 0; 17986 17987 /* Prepare storage */ 17988 parts.resize(source.m_parts.size()); 17989 17990 /* Prepare arrays */ 17991 for (GLuint i = 0; i < source.m_parts.size(); ++i) 17992 { 17993 parts[i] = source.m_parts[i].m_code.c_str(); 17994 } 17995 17996 if (true == source.m_use_lengths) 17997 { 17998 lengths_vector.resize(source.m_parts.size()); 17999 18000 for (GLuint i = 0; i < source.m_parts.size(); ++i) 18001 { 18002 lengths_vector[i] = source.m_parts[i].m_length; 18003 } 18004 18005 lengths = &lengths_vector[0]; 18006 } 18007 18008 /* Set source code */ 18009 gl.shaderSource(shader_id, static_cast<GLsizei>(source.m_parts.size()), &parts[0], lengths); 18010 GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource"); 18011 18012 /* Compile */ 18013 gl.compileShader(shader_id); 18014 GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader"); 18015 18016 /* Get compilation status */ 18017 gl.getShaderiv(shader_id, GL_COMPILE_STATUS, &status); 18018 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); 18019 18020 /* Log compilation error */ 18021 if (GL_TRUE != status) 18022 { 18023 glw::GLint length = 0; 18024 std::vector<glw::GLchar> message; 18025 18026 /* Error log length */ 18027 gl.getShaderiv(shader_id, GL_INFO_LOG_LENGTH, &length); 18028 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); 18029 18030 /* Prepare storage */ 18031 message.resize(length); 18032 18033 /* Get error log */ 18034 gl.getShaderInfoLog(shader_id, length, 0, &message[0]); 18035 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog"); 18036 18037 throw shaderCompilationException(source, &message[0]); 18038 } 18039 } 18040 18041 /** Create program from provided binary 18042 * 18043 * @param binary Buffer with binary form of program 18044 * @param binary_format Format of <binary> data 18045 **/ 18046 void Utils::program::createFromBinary(const std::vector<GLubyte>& binary, GLenum binary_format) 18047 { 18048 /* GL entry points */ 18049 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18050 18051 /* Create program object */ 18052 m_program_object_id = gl.createProgram(); 18053 GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); 18054 18055 gl.programBinary(m_program_object_id, binary_format, &binary[0], static_cast<GLsizei>(binary.size())); 18056 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramBinary"); 18057 } 18058 18059 glw::GLint Utils::program::getAttribLocation(const glw::GLchar* name) const 18060 { 18061 /* GL entry points */ 18062 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18063 18064 GLint location = gl.getAttribLocation(m_program_object_id, name); 18065 GLU_EXPECT_NO_ERROR(gl.getError(), "GetAttribLocation"); 18066 18067 return location; 18068 } 18069 18070 /** Get binary form of program 18071 * 18072 * @param binary Buffer for binary data 18073 * @param binary_format Format of binary data 18074 **/ 18075 void Utils::program::getBinary(std::vector<GLubyte>& binary, GLenum& binary_format) const 18076 { 18077 /* GL entry points */ 18078 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18079 18080 /* Get binary size */ 18081 GLint length = 0; 18082 gl.getProgramiv(m_program_object_id, GL_PROGRAM_BINARY_LENGTH, &length); 18083 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 18084 18085 /* Allocate storage */ 18086 binary.resize(length); 18087 18088 /* Get binary */ 18089 gl.getProgramBinary(m_program_object_id, static_cast<GLsizei>(binary.size()), &length, &binary_format, &binary[0]); 18090 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramBinary"); 18091 } 18092 18093 /** Get subroutine index 18094 * 18095 * @param subroutine_name Subroutine name 18096 * 18097 * @return Index of subroutine 18098 **/ 18099 GLuint Utils::program::getSubroutineIndex(const glw::GLchar* subroutine_name, glw::GLenum shader_stage) const 18100 { 18101 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18102 GLuint index = -1; 18103 18104 index = gl.getSubroutineIndex(m_program_object_id, shader_stage, subroutine_name); 18105 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex"); 18106 18107 if (GL_INVALID_INDEX == index) 18108 { 18109 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine: " << subroutine_name 18110 << " is not available" << tcu::TestLog::EndMessage; 18111 18112 TCU_FAIL("Subroutine is not available"); 18113 } 18114 18115 return index; 18116 } 18117 18118 /** Get subroutine uniform location 18119 * 18120 * @param uniform_name Subroutine uniform name 18121 * 18122 * @return Location of subroutine uniform 18123 **/ 18124 GLint Utils::program::getSubroutineUniformLocation(const glw::GLchar* uniform_name, glw::GLenum shader_stage) const 18125 { 18126 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18127 GLint location = -1; 18128 18129 location = gl.getSubroutineUniformLocation(m_program_object_id, shader_stage, uniform_name); 18130 GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation"); 18131 18132 if (-1 == location) 18133 { 18134 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine uniform: " << uniform_name 18135 << " is not available" << tcu::TestLog::EndMessage; 18136 18137 TCU_FAIL("Subroutine uniform is not available"); 18138 } 18139 18140 return location; 18141 } 18142 18143 /** Get integer uniform at given location 18144 * 18145 * @param location Uniform location 18146 * 18147 * @return Value 18148 **/ 18149 GLint Utils::program::getUniform1i(GLuint location) const 18150 { 18151 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18152 18153 GLint result; 18154 18155 gl.getUniformiv(m_program_object_id, location, &result); 18156 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformiv"); 18157 18158 return result; 18159 } 18160 18161 /** Get uniform location 18162 * 18163 * @param uniform_name Subroutine uniform name 18164 * 18165 * @return Location of uniform 18166 **/ 18167 GLint Utils::program::getUniformLocation(const glw::GLchar* uniform_name) const 18168 { 18169 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18170 GLint location = -1; 18171 18172 location = gl.getUniformLocation(m_program_object_id, uniform_name); 18173 GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); 18174 18175 if (-1 == location) 18176 { 18177 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Uniform: " << uniform_name 18178 << " is not available" << tcu::TestLog::EndMessage; 18179 18180 TCU_FAIL("Uniform is not available"); 18181 } 18182 18183 return location; 18184 } 18185 18186 /** Attach shaders and link program 18187 * 18188 **/ 18189 void Utils::program::link() const 18190 { 18191 /* GL entry points */ 18192 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18193 18194 /* Link status */ 18195 glw::GLint status = GL_FALSE; 18196 18197 /* Attach shaders */ 18198 if (0 != m_compute_shader_id) 18199 { 18200 gl.attachShader(m_program_object_id, m_compute_shader_id); 18201 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 18202 } 18203 18204 if (0 != m_fragment_shader_id) 18205 { 18206 gl.attachShader(m_program_object_id, m_fragment_shader_id); 18207 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 18208 } 18209 18210 if (0 != m_geometry_shader_id) 18211 { 18212 gl.attachShader(m_program_object_id, m_geometry_shader_id); 18213 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 18214 } 18215 18216 if (0 != m_tesselation_control_shader_id) 18217 { 18218 gl.attachShader(m_program_object_id, m_tesselation_control_shader_id); 18219 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 18220 } 18221 18222 if (0 != m_tesselation_evaluation_shader_id) 18223 { 18224 gl.attachShader(m_program_object_id, m_tesselation_evaluation_shader_id); 18225 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 18226 } 18227 18228 if (0 != m_vertex_shader_id) 18229 { 18230 gl.attachShader(m_program_object_id, m_vertex_shader_id); 18231 GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); 18232 } 18233 18234 /* Link */ 18235 gl.linkProgram(m_program_object_id); 18236 GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram"); 18237 18238 /* Get link status */ 18239 gl.getProgramiv(m_program_object_id, GL_LINK_STATUS, &status); 18240 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 18241 18242 /* Log link error */ 18243 if (GL_TRUE != status) 18244 { 18245 glw::GLint length = 0; 18246 std::vector<glw::GLchar> message; 18247 18248 /* Get error log length */ 18249 gl.getProgramiv(m_program_object_id, GL_INFO_LOG_LENGTH, &length); 18250 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 18251 18252 message.resize(length); 18253 18254 /* Get error log */ 18255 gl.getProgramInfoLog(m_program_object_id, length, 0, &message[0]); 18256 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); 18257 18258 throw programLinkageException(&message[0]); 18259 } 18260 } 18261 18262 /** Delete program object and all attached shaders 18263 * 18264 **/ 18265 void Utils::program::remove() 18266 { 18267 /* GL entry points */ 18268 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18269 18270 /* Make sure program object is no longer used by GL */ 18271 gl.useProgram(0); 18272 18273 /* Clean program object */ 18274 if (0 != m_program_object_id) 18275 { 18276 gl.deleteProgram(m_program_object_id); 18277 m_program_object_id = 0; 18278 } 18279 18280 /* Clean shaders */ 18281 if (0 != m_compute_shader_id) 18282 { 18283 gl.deleteShader(m_compute_shader_id); 18284 m_compute_shader_id = 0; 18285 } 18286 18287 if (0 != m_fragment_shader_id) 18288 { 18289 gl.deleteShader(m_fragment_shader_id); 18290 m_fragment_shader_id = 0; 18291 } 18292 18293 if (0 != m_geometry_shader_id) 18294 { 18295 gl.deleteShader(m_geometry_shader_id); 18296 m_geometry_shader_id = 0; 18297 } 18298 18299 if (0 != m_tesselation_control_shader_id) 18300 { 18301 gl.deleteShader(m_tesselation_control_shader_id); 18302 m_tesselation_control_shader_id = 0; 18303 } 18304 18305 if (0 != m_tesselation_evaluation_shader_id) 18306 { 18307 gl.deleteShader(m_tesselation_evaluation_shader_id); 18308 m_tesselation_evaluation_shader_id = 0; 18309 } 18310 18311 if (0 != m_vertex_shader_id) 18312 { 18313 gl.deleteShader(m_vertex_shader_id); 18314 m_vertex_shader_id = 0; 18315 } 18316 } 18317 18318 void Utils::program::uniform(const glw::GLchar* uniform_name, TYPES type, glw::GLuint n_columns, glw::GLuint n_rows, 18319 const void* data) const 18320 { 18321 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18322 18323 GLuint location = getUniformLocation(uniform_name); 18324 18325 if ((glw::GLuint)-1 == location) 18326 { 18327 TCU_FAIL("Uniform is inactive"); 18328 } 18329 18330 switch (type) 18331 { 18332 case DOUBLE: 18333 if (1 == n_columns) 18334 { 18335 getUniformNdv(gl, n_rows)(location, 1 /* count */, (const GLdouble*)data); 18336 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformNdv"); 18337 } 18338 else 18339 { 18340 getUniformMatrixNdv(gl, n_columns, n_rows)(location, 1 /* count */, false, (const GLdouble*)data); 18341 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformMatrixNdv"); 18342 } 18343 break; 18344 case FLOAT: 18345 if (1 == n_columns) 18346 { 18347 getUniformNfv(gl, n_rows)(location, 1 /* count */, (const GLfloat*)data); 18348 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformNfv"); 18349 } 18350 else 18351 { 18352 getUniformMatrixNfv(gl, n_columns, n_rows)(location, 1 /* count */, false, (const GLfloat*)data); 18353 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformMatrixNfv"); 18354 } 18355 break; 18356 case INT: 18357 getUniformNiv(gl, n_rows)(location, 1 /* count */, (const GLint*)data); 18358 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformNiv"); 18359 break; 18360 case UINT: 18361 getUniformNuiv(gl, n_rows)(location, 1 /* count */, (const GLuint*)data); 18362 GLU_EXPECT_NO_ERROR(gl.getError(), "UniformNuiv"); 18363 break; 18364 default: 18365 TCU_FAIL("Invalid enum"); 18366 } 18367 } 18368 18369 /** Execute UseProgram 18370 * 18371 **/ 18372 void Utils::program::use() const 18373 { 18374 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18375 18376 gl.useProgram(m_program_object_id); 18377 GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); 18378 } 18379 18380 void Utils::program::printShaderSource(const shaderSource& source, tcu::MessageBuilder& log) 18381 { 18382 GLuint line_number = 0; 18383 18384 log << "Shader source."; 18385 18386 for (GLuint i = 0; i < source.m_parts.size(); ++i) 18387 { 18388 log << "\nLine||Part: " << (i + 1) << "/" << source.m_parts.size(); 18389 18390 if (true == source.m_use_lengths) 18391 { 18392 log << " Length: " << source.m_parts[i].m_length; 18393 } 18394 18395 log << "\n"; 18396 18397 const GLchar* part = source.m_parts[i].m_code.c_str(); 18398 18399 while (0 != part) 18400 { 18401 std::string line; 18402 const GLchar* next_line = strchr(part, '\n'); 18403 18404 if (0 != next_line) 18405 { 18406 next_line += 1; 18407 line.assign(part, next_line - part); 18408 } 18409 else 18410 { 18411 line = part; 18412 } 18413 18414 if (0 != *part) 18415 { 18416 log << std::setw(4) << line_number << "||" << line; 18417 } 18418 18419 part = next_line; 18420 line_number += 1; 18421 } 18422 } 18423 } 18424 18425 /** Constructor. 18426 * 18427 * @param context CTS context. 18428 **/ 18429 Utils::texture::texture(deqp::Context& context) : m_id(0), m_context(context), m_texture_type(TEX_2D) 18430 { 18431 /* Nothing to done here */ 18432 } 18433 18434 /** Destructor 18435 * 18436 **/ 18437 Utils::texture::~texture() 18438 { 18439 release(); 18440 } 18441 18442 /** Bind texture to GL_TEXTURE_2D 18443 * 18444 **/ 18445 void Utils::texture::bind() const 18446 { 18447 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18448 18449 GLenum target = getTextureTartet(m_texture_type); 18450 18451 gl.bindTexture(target, m_id); 18452 GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); 18453 } 18454 18455 /** Create 2d texture 18456 * 18457 * @param width Width of texture 18458 * @param height Height of texture 18459 * @param internal_format Internal format of texture 18460 **/ 18461 void Utils::texture::create(glw::GLuint width, glw::GLuint height, glw::GLenum internal_format) 18462 { 18463 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18464 18465 release(); 18466 18467 m_texture_type = TEX_2D; 18468 18469 gl.genTextures(1, &m_id); 18470 GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); 18471 18472 bind(); 18473 18474 gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, internal_format, width, height); 18475 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D"); 18476 } 18477 18478 /** Create texture of given type 18479 * 18480 * @param width Width of texture 18481 * @param height Height of texture 18482 * @param depth Depth of texture 18483 * @param internal_format Internal format of texture 18484 * @param texture_type Type of texture 18485 **/ 18486 void Utils::texture::create(GLuint width, GLuint height, GLuint depth, GLenum internal_format, 18487 TEXTURE_TYPES texture_type) 18488 { 18489 static const GLuint levels = 1; 18490 18491 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18492 18493 release(); 18494 18495 m_texture_type = texture_type; 18496 18497 GLenum target = getTextureTartet(m_texture_type); 18498 18499 gl.genTextures(1, &m_id); 18500 GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); 18501 18502 bind(); 18503 18504 switch (m_texture_type) 18505 { 18506 case TEX_1D: 18507 gl.texStorage1D(target, levels, internal_format, width); 18508 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage1D"); 18509 break; 18510 case TEX_2D: 18511 case TEX_1D_ARRAY: 18512 case TEX_2D_RECT: 18513 case TEX_CUBE: 18514 gl.texStorage2D(target, levels, internal_format, width, height); 18515 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D"); 18516 break; 18517 case TEX_3D: 18518 case TEX_2D_ARRAY: 18519 gl.texStorage3D(target, levels, internal_format, width, height, depth); 18520 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage3D"); 18521 break; 18522 default: 18523 TCU_FAIL("Invliad enum"); 18524 break; 18525 } 18526 } 18527 18528 /** Create buffer texture 18529 * 18530 * @param internal_format Internal format of texture 18531 * @param buffer_id Id of buffer that will be used as data source 18532 **/ 18533 void Utils::texture::createBuffer(GLenum internal_format, GLuint buffer_id) 18534 { 18535 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18536 18537 release(); 18538 18539 m_texture_type = TEX_BUFFER; 18540 m_buffer_id = buffer_id; 18541 18542 gl.genTextures(1, &m_id); 18543 GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); 18544 18545 bind(); 18546 18547 gl.texBuffer(GL_TEXTURE_BUFFER, internal_format, buffer_id); 18548 GLU_EXPECT_NO_ERROR(gl.getError(), "TexBuffer"); 18549 } 18550 18551 /** Get contents of texture 18552 * 18553 * @param format Format of image 18554 * @param type Type of image 18555 * @param out_data Buffer for image 18556 **/ 18557 void Utils::texture::get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data) const 18558 { 18559 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18560 18561 GLenum target = getTextureTartet(m_texture_type); 18562 18563 bind(); 18564 18565 gl.memoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT); 18566 GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier"); 18567 18568 if (TEX_CUBE != m_texture_type) 18569 { 18570 gl.getTexImage(target, 0 /* level */, format, type, out_data); 18571 GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage"); 18572 } 18573 else 18574 { 18575 GLint width; 18576 GLint height; 18577 18578 if ((GL_RGBA != format) && (GL_UNSIGNED_BYTE != type)) 18579 { 18580 TCU_FAIL("Not implemented"); 18581 } 18582 18583 GLuint texel_size = 4; 18584 18585 gl.getTexLevelParameteriv(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0 /* level */, GL_TEXTURE_WIDTH, &width); 18586 GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexLevelParameteriv"); 18587 18588 gl.getTexLevelParameteriv(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0 /* level */, GL_TEXTURE_HEIGHT, &height); 18589 GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexLevelParameteriv"); 18590 18591 const GLuint image_size = width * height * texel_size; 18592 18593 gl.getTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0 /* level */, format, type, 18594 (GLvoid*)((GLchar*)out_data + (image_size * 0))); 18595 gl.getTexImage(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0 /* level */, format, type, 18596 (GLvoid*)((GLchar*)out_data + (image_size * 1))); 18597 gl.getTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0 /* level */, format, type, 18598 (GLvoid*)((GLchar*)out_data + (image_size * 2))); 18599 gl.getTexImage(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0 /* level */, format, type, 18600 (GLvoid*)((GLchar*)out_data + (image_size * 3))); 18601 gl.getTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0 /* level */, format, type, 18602 (GLvoid*)((GLchar*)out_data + (image_size * 4))); 18603 gl.getTexImage(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0 /* level */, format, type, 18604 (GLvoid*)((GLchar*)out_data + (image_size * 5))); 18605 GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage"); 18606 } 18607 } 18608 18609 /** Delete texture 18610 * 18611 **/ 18612 void Utils::texture::release() 18613 { 18614 if (0 != m_id) 18615 { 18616 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18617 18618 gl.deleteTextures(1, &m_id); 18619 m_id = 0; 18620 18621 if ((m_texture_type == TEX_BUFFER) && (0 != m_buffer_id)) 18622 { 18623 gl.deleteBuffers(1, &m_buffer_id); 18624 m_buffer_id = 0; 18625 } 18626 } 18627 } 18628 18629 /** Update contents of texture 18630 * 18631 * @param width Width of texture 18632 * @param height Height of texture 18633 * @param format Format of data 18634 * @param type Type of data 18635 * @param data Buffer with image 18636 **/ 18637 void Utils::texture::update(glw::GLuint width, glw::GLuint height, glw::GLuint depth, glw::GLenum format, 18638 glw::GLenum type, glw::GLvoid* data) 18639 { 18640 static const GLuint level = 0; 18641 18642 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18643 18644 GLenum target = getTextureTartet(m_texture_type); 18645 18646 bind(); 18647 18648 switch (m_texture_type) 18649 { 18650 case TEX_1D: 18651 gl.texSubImage1D(target, level, 0 /* x */, width, format, type, data); 18652 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage1D"); 18653 break; 18654 case TEX_2D: 18655 case TEX_1D_ARRAY: 18656 case TEX_2D_RECT: 18657 gl.texSubImage2D(target, level, 0 /* x */, 0 /* y */, width, height, format, type, data); 18658 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D"); 18659 break; 18660 case TEX_CUBE: 18661 gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, 0 /* x */, 0 /* y */, width, height, format, type, 18662 data); 18663 gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, level, 0 /* x */, 0 /* y */, width, height, format, type, 18664 data); 18665 gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, level, 0 /* x */, 0 /* y */, width, height, format, type, 18666 data); 18667 gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, level, 0 /* x */, 0 /* y */, width, height, format, type, 18668 data); 18669 gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, level, 0 /* x */, 0 /* y */, width, height, format, type, 18670 data); 18671 gl.texSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, level, 0 /* x */, 0 /* y */, width, height, format, type, 18672 data); 18673 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D"); 18674 break; 18675 case TEX_3D: 18676 case TEX_2D_ARRAY: 18677 gl.texSubImage3D(target, level, 0 /* x */, 0 /* y */, 0 /* z */, width, height, depth, format, type, data); 18678 GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage3D"); 18679 break; 18680 default: 18681 TCU_FAIL("Invliad enum"); 18682 break; 18683 } 18684 } 18685 18686 /** Constructor. 18687 * 18688 * @param context CTS context. 18689 **/ 18690 Utils::vertexArray::vertexArray(deqp::Context& context) : m_id(0), m_context(context) 18691 { 18692 } 18693 18694 /** Destructor 18695 * 18696 **/ 18697 Utils::vertexArray::~vertexArray() 18698 { 18699 if (0 != m_id) 18700 { 18701 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18702 18703 gl.deleteVertexArrays(1, &m_id); 18704 18705 m_id = 0; 18706 } 18707 } 18708 18709 /** Execute BindVertexArray 18710 * 18711 **/ 18712 void Utils::vertexArray::bind() 18713 { 18714 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18715 18716 gl.bindVertexArray(m_id); 18717 GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); 18718 } 18719 18720 /** Execute GenVertexArrays 18721 * 18722 **/ 18723 void Utils::vertexArray::generate() 18724 { 18725 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 18726 18727 gl.genVertexArrays(1, &m_id); 18728 GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); 18729 } 18730 } /* GLSL420Pack namespace */ 18731 18732 /** Constructor. 18733 * 18734 * @param context Rendering context. 18735 **/ 18736 ShadingLanguage420PackTests::ShadingLanguage420PackTests(deqp::Context& context) 18737 : TestCaseGroup(context, "shading_language_420pack", "Verifies \"shading_language_420pack\" functionality") 18738 { 18739 /* Left blank on purpose */ 18740 } 18741 18742 /** Initializes a texture_storage_multisample test group. 18743 * 18744 **/ 18745 void ShadingLanguage420PackTests::init(void) 18746 { 18747 addChild(new GLSL420Pack::BindingSamplerSingleTest(m_context)); 18748 addChild(new GLSL420Pack::BindingImageSingleTest(m_context)); 18749 addChild(new GLSL420Pack::UTF8CharactersTest(m_context)); 18750 addChild(new GLSL420Pack::UTF8InSourceTest(m_context)); 18751 addChild(new GLSL420Pack::QualifierOrderTest(m_context)); 18752 addChild(new GLSL420Pack::QualifierOrderBlockTest(m_context)); 18753 addChild(new GLSL420Pack::LineContinuationTest(m_context)); 18754 addChild(new GLSL420Pack::LineNumberingTest(m_context)); 18755 addChild(new GLSL420Pack::ImplicitConversionsValidTest(m_context)); 18756 addChild(new GLSL420Pack::ImplicitConversionsInvalidTest(m_context)); 18757 addChild(new GLSL420Pack::ConstDynamicValueTest(m_context)); 18758 addChild(new GLSL420Pack::ConstAssignmentTest(m_context)); 18759 addChild(new GLSL420Pack::ConstDynamicValueAsConstExprTest(m_context)); 18760 addChild(new GLSL420Pack::QualifierOrderUniformTest(m_context)); 18761 addChild(new GLSL420Pack::QualifierOrderFunctionInoutTest(m_context)); 18762 addChild(new GLSL420Pack::QualifierOrderFunctionInputTest(m_context)); 18763 addChild(new GLSL420Pack::QualifierOrderFunctionOutputTest(m_context)); 18764 addChild(new GLSL420Pack::QualifierOverrideLayoutTest(m_context)); 18765 addChild(new GLSL420Pack::BindingUniformBlocksTest(m_context)); 18766 addChild(new GLSL420Pack::BindingUniformSingleBlockTest(m_context)); 18767 addChild(new GLSL420Pack::BindingUniformBlockArrayTest(m_context)); 18768 addChild(new GLSL420Pack::BindingUniformDefaultTest(m_context)); 18769 addChild(new GLSL420Pack::BindingUniformAPIOverirdeTest(m_context)); 18770 addChild(new GLSL420Pack::BindingUniformGlobalBlockTest(m_context)); 18771 addChild(new GLSL420Pack::BindingUniformInvalidTest(m_context)); 18772 addChild(new GLSL420Pack::BindingSamplersTest(m_context)); 18773 addChild(new GLSL420Pack::BindingSamplerArrayTest(m_context)); 18774 addChild(new GLSL420Pack::BindingSamplerDefaultTest(m_context)); 18775 addChild(new GLSL420Pack::BindingSamplerAPIOverrideTest(m_context)); 18776 addChild(new GLSL420Pack::BindingSamplerInvalidTest(m_context)); 18777 addChild(new GLSL420Pack::BindingImagesTest(m_context)); 18778 addChild(new GLSL420Pack::BindingImageArrayTest(m_context)); 18779 addChild(new GLSL420Pack::BindingImageDefaultTest(m_context)); 18780 addChild(new GLSL420Pack::BindingImageAPIOverrideTest(m_context)); 18781 addChild(new GLSL420Pack::BindingImageInvalidTest(m_context)); 18782 addChild(new GLSL420Pack::InitializerListTest(m_context)); 18783 addChild(new GLSL420Pack::InitializerListNegativeTest(m_context)); 18784 addChild(new GLSL420Pack::LengthOfVectorAndMatrixTest(m_context)); 18785 addChild(new GLSL420Pack::LengthOfComputeResultTest(m_context)); 18786 addChild(new GLSL420Pack::ScalarSwizzlersTest(m_context)); 18787 addChild(new GLSL420Pack::ScalarSwizzlersInvalidTest(m_context)); 18788 addChild(new GLSL420Pack::BuiltInValuesTest(m_context)); 18789 addChild(new GLSL420Pack::BuiltInAssignmentTest(m_context)); 18790 } 18791 18792 } /* gl4cts namespace */ 18793
