modules/gles3/scripts/gen-uniform-blocks.py

   1 # -*- coding: utf-8 -*-
   2
   3 #-------------------------------------------------------------------------
   4 # drawElements Quality Program utilities
   5 # --------------------------------------
   6 #
   7 # Copyright 2015 The Android Open Source Project
   8 #
   9 # Licensed under the Apache License, Version 2.0 (the "License");
  10 # you may not use this file except in compliance with the License.
  11 # You may obtain a copy of the License at
  12 #
  13 #      http://www.apache.org/licenses/LICENSE-2.0
  14 #
  15 # Unless required by applicable law or agreed to in writing, software
  16 # distributed under the License is distributed on an "AS IS" BASIS,
  17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18 # See the License for the specific language governing permissions and
  19 # limitations under the License.
  20 #
  21 #-------------------------------------------------------------------------
  22
  23 from genutil import *
  24
  25 allCases = []
  26
  27 VERTEX = "VERTEX"
  28 FRAGMENT = "FRAGMENT"
  29
  30 CASE_FRAGMENT_SHADER_TEMPLATE = """
  31 case ${{NAME}}
  32         version 300 es
  33         expect ${{EXPECT}}
  34
  35         vertex ""
  36                 #version 300 es
  37                 precision highp float;
  38
  39                 in vec4 a_pos;
  40
  41                 void main()
  42                 {
  43                         gl_Position = a_pos;
  44                 }
  45         ""
  46
  47         fragment ""
  48                 ${{SOURCE}}
  49         ""
  50 end"""[1:]
  51
  52 CASE_VERTEX_SHADER_TEMPLATE = """
  53 case ${{NAME}}
  54         version 300 es
  55         expect ${{EXPECT}}
  56
  57         vertex ""
  58                 ${{SOURCE}}
  59         ""
  60
  61         fragment ""
  62                 #version 300 es
  63                 precision highp float;
  64
  65                 layout(location=0) out vec4 o_color;
  66
  67                 void main()
  68                 {
  69                         o_color = vec4(1.0);
  70                 }
  71         ""
  72 end"""[1:]
  73
  74 class UniformBlockCase(ShaderCase):
  75         def __init__(self, name, shaderType, source, valid):
  76                 self.name = name
  77                 self.shaderType = shaderType
  78                 self.source = source
  79                 self.valid = valid
  80
  81         def __str__(self):
  82                 if self.shaderType == FRAGMENT:
  83                         sourceParams = {
  84                                 "OUTPUT":                               "o_color",
  85                                 "OUTPUT_DECLARATION":   "layout(location=0) out vec4 o_color;"
  86                         }
  87
  88                         source = fillTemplate(self.source, sourceParams)
  89
  90                         testCaseParams = {
  91                                 "NAME":         self.name,
  92                                 "SOURCE":       source,
  93                                 "EXPECT":       ("build_successful" if self.valid else "compile_fail")
  94                         }
  95
  96                         return fillTemplate(CASE_FRAGMENT_SHADER_TEMPLATE, testCaseParams)
  97                 elif self.shaderType == VERTEX:
  98                         sourceParams = {
  99                                 "OUTPUT":                               "gl_Position",
 100                                 "OUTPUT_DECLARATION":   ""
 101                         }
 102
 103                         source = fillTemplate(self.source, sourceParams)
 104
 105                         testCaseParams = {
 106                                 "NAME":         self.name,
 107                                 "SOURCE":       source,
 108                                 "EXPECT":       ("build_successful" if self.valid else "compile_fail")
 109                         }
 110
 111                         return fillTemplate(CASE_VERTEX_SHADER_TEMPLATE, testCaseParams)
 112
 113                 assert False
 114
 115 def createCases(name, source, valid):
 116         return [UniformBlockCase(name + "_vertex", VERTEX, source, valid),
 117                         UniformBlockCase(name + "_fragment", FRAGMENT, source, valid)]
 118
 119 repeatShaderTemplate = """
 120 #version 300 es
 121 precision highp float;
 122
 123 ${{OUTPUT_DECLARATION}}
 124
 125 uniform UniformBlock
 126 {
 127         uniform vec4 uniformMember;
 128 } uniformBlock;
 129
 130 void main()
 131 {
 132         ${{OUTPUT}} = uniformBlock.uniformMember;
 133 }"""[1:]
 134
 135 layoutQualifierShaderTemplate = """
 136 #version 300 es
 137 precision highp float;
 138
 139 ${{OUTPUT_DECLARATION}}
 140
 141 layout(%s) uniform UniformBlock
 142 {
 143         vec4 uniformMember;
 144 } uniformBlock;
 145
 146 void main()
 147 {
 148         ${{OUTPUT}} = uniformBlock.uniformMember;
 149 }"""[1:]
 150
 151 layoutGlobalQualifierShaderTemplate = """
 152 #version 300 es
 153 precision highp float;
 154
 155 layout(%s) uniform;
 156
 157 ${{OUTPUT_DECLARATION}}
 158
 159 uniform UniformBlock
 160 {
 161         vec4 uniformMember;
 162 } uniformBlock;
 163
 164 void main()
 165 {
 166         ${{OUTPUT}} = uniformBlock.uniformMember;
 167 }"""[1:]
 168
 169 layoutMemberQualifierShaderTemplate = """
 170 #version 300 es
 171 precision highp float;
 172
 173 ${{OUTPUT_DECLARATION}}
 174
 175 uniform UniformBlock
 176 {
 177         layout(%s) mat4 uniformMember;
 178 } uniformBlock;
 179
 180 void main()
 181 {
 182         ${{OUTPUT}} = uniformBlock.uniformMember[0];
 183 }"""[1:]
 184
 185 layoutMemberVec4QualifierShaderTemplate = """
 186 #version 300 es
 187 precision highp float;
 188
 189 ${{OUTPUT_DECLARATION}}
 190
 191 uniform UniformBlock
 192 {
 193         layout(%s) vec4 uniformMember;
 194 } uniformBlock;
 195
 196 void main()
 197 {
 198         ${{OUTPUT}} = uniformBlock.uniformMember;
 199 }"""[1:]
 200
 201 noInstanceNameShaderTemplate = """
 202 #version 300 es
 203 precision highp float;
 204
 205 ${{OUTPUT_DECLARATION}}
 206
 207 uniform UniformBlock
 208 {
 209         vec4 uniformMember;
 210 };
 211
 212 void main()
 213 {
 214         ${{OUTPUT}} = uniformMember;
 215 }"""[1:]
 216
 217 sameVariableAndInstanceNameShaderTemplate = """
 218 #version 300 es
 219 precision highp float;
 220
 221 ${{OUTPUT_DECLARATION}}
 222
 223 uniform UniformBlock
 224 {
 225         vec4 uniformMember;
 226 } uniformBlock;
 227
 228 void main()
 229 {
 230         vec4 uniformBlock = vec4(0.0);
 231         ${{OUTPUT}} = uniformBlock;
 232 }"""[1:]
 233
 234 sameVariableAndBlockNameShaderTemplate = """
 235 #version 300 es
 236 precision highp float;
 237
 238 ${{OUTPUT_DECLARATION}}
 239
 240 uniform UniformBlock
 241 {
 242         vec4 uniformMember;
 243 } uniformBlock;
 244
 245 void main()
 246 {
 247         vec4 UniformBlock = vec4(0.0);
 248         ${{OUTPUT}} = UniformBlock + uniformBlock.uniformMember;
 249 }"""[1:]
 250
 251 repeatedBlockShaderTemplate = """
 252 #version 300 es
 253 precision highp float;
 254
 255 ${{OUTPUT_DECLARATION}}
 256
 257 uniform UniformBlock
 258 {
 259         vec4 uniformMember;
 260 } uniformBlockA;
 261
 262 uniform UniformBlock
 263 {
 264         vec4 uniformMember;
 265 } uniformBlockB;
 266
 267 void main()
 268 {
 269         ${{OUTPUT}} = uniformBlockA.uniformMember + uniformBlockB.uniformMember;
 270 }"""[1:]
 271
 272 repeatedBlockNoInstanceNameShaderTemplate = """
 273 #version 300 es
 274 precision highp float;
 275
 276 ${{OUTPUT_DECLARATION}}
 277
 278 uniform UniformBlock
 279 {
 280         vec4 uniformMember;
 281 } uniformBlock;
 282
 283 uniform UniformBlock
 284 {
 285         vec4 uniformMember;
 286 };
 287
 288 void main()
 289 {
 290         ${{OUTPUT}} = uniformBlock.uniformMember + uniformMember;
 291 }"""[1:]
 292
 293 structMemberShaderTemplate = """
 294 #version 300 es
 295 precision highp float;
 296
 297 ${{OUTPUT_DECLARATION}}
 298
 299 struct Struct
 300 {
 301         vec4 uniformMember;
 302 };
 303
 304 uniform UniformBlock
 305 {
 306         Struct st;
 307 } uniformBlock;
 308
 309 void main()
 310 {
 311         ${{OUTPUT}} = uniformBlock.st.uniformMember;
 312 }"""[1:]
 313
 314 layoutStructMemberQualifierShaderTemplate = """
 315 #version 300 es
 316 precision highp float;
 317
 318 ${{OUTPUT_DECLARATION}}
 319
 320 struct Struct
 321 {
 322         vec4 uniformMember;
 323 };
 324
 325 uniform UniformBlock
 326 {
 327         layout(%s) Struct st;
 328 } uniformBlock;
 329
 330 void main()
 331 {
 332         ${{OUTPUT}} = uniformBlock.st.uniformMember;
 333 }"""[1:]
 334
 335 longIdentifierBlockNameShaderTemplate = ("""
 336 #version 300 es
 337 precision highp float;
 338
 339 ${{OUTPUT_DECLARATION}}
 340
 341 // Total of 1024 characters
 342 uniform """ + ("a" * 1024) + """
 343 {
 344         vec4 uniformMember;
 345 } uniformBlock;
 346
 347 void main()
 348 {
 349         ${{OUTPUT}} = uniformBlock.uniformMember;
 350 }""")[1:]
 351
 352 longIdentifierInstanceNameShaderTemplate = ("""
 353 #version 300 es
 354 precision highp float;
 355
 356 ${{OUTPUT_DECLARATION}}
 357
 358 uniform UniformBlock
 359 {
 360         vec4 uniformMember;
 361 } """ + ("a" * 1024) + """;
 362 // Total of 1024 characters
 363
 364 void main()
 365 {
 366         ${{OUTPUT}} = """ + ("a" * 1024) + """.uniformMember;
 367 }""")[1:]
 368
 369 underscoreIdentifierInstanceNameShaderTemplate = ("""
 370 #version 300 es
 371 precision highp float;
 372
 373 ${{OUTPUT_DECLARATION}}
 374
 375 uniform UniformBlock
 376 {
 377         vec4 uniformMember;
 378 } _;
 379
 380 void main()
 381 {
 382         ${{OUTPUT}} = _.uniformMember;
 383 }""")[1:]
 384
 385 underscoreIdentifierBlockNameShaderTemplate = ("""
 386 #version 300 es
 387 precision highp float;
 388
 389 ${{OUTPUT_DECLARATION}}
 390
 391 uniform _
 392 {
 393         vec4 uniformMember;
 394 } uniformBlock;
 395
 396 void main()
 397 {
 398         ${{OUTPUT}} = uniformBlock.uniformMember;
 399 }""")[1:]
 400
 401 validCases = (createCases("repeat_interface_qualifier", repeatShaderTemplate, True)
 402                         + sum([createCases("layout_%s" % qualifier, layoutQualifierShaderTemplate % qualifier, True)
 403                                                 for qualifier in ["shared", "packed", "std140", "row_major", "column_major"]], [])
 404                         + createCases("layout_all", layoutQualifierShaderTemplate % "shared, packed, std140, row_major, column_major", True)
 405                         + createCases("layout_all_8_times", layoutQualifierShaderTemplate % str.join(", ", ["shared", "packed", "std140", "row_major", "column_major"] * 8), True)
 406                         + sum([createCases("global_layout_%s" % qualifier, layoutGlobalQualifierShaderTemplate % qualifier, True)
 407                                                 for qualifier in ["shared", "packed", "std140", "row_major", "column_major"]], [])
 408                         + createCases("global_layout_all", layoutGlobalQualifierShaderTemplate % "shared, packed, std140, row_major, column_major", True)
 409                         + createCases("global_layout_all_8_times", layoutGlobalQualifierShaderTemplate % str.join(", ", ["shared", "packed", "std140", "row_major", "column_major"] * 8), True)
 410                         + sum([createCases("member_layout_%s" % qualifier, layoutMemberQualifierShaderTemplate % qualifier, True)
 411                                                 for qualifier in ["row_major", "column_major"]], [])
 412                         + sum([createCases("member_layout_%s_vec4" % qualifier, layoutMemberVec4QualifierShaderTemplate % qualifier, True)
 413                                                 for qualifier in ["row_major", "column_major"]], [])
 414                         + createCases("member_layout_all", layoutMemberQualifierShaderTemplate % "row_major, column_major", True)
 415                         + createCases("member_layout_all_8_times", layoutMemberQualifierShaderTemplate % str.join(", ", ["row_major", "column_major"] * 8), True)
 416                         + createCases("no_instance_name", noInstanceNameShaderTemplate, True)
 417                         + createCases("same_variable_and_block_name", sameVariableAndBlockNameShaderTemplate, True)
 418                         + createCases("same_variable_and_instance_name", sameVariableAndInstanceNameShaderTemplate, True)
 419                         + createCases("struct_member", structMemberShaderTemplate, True)
 420                         + sum([createCases("struct_member_layout_%s" % qualifier, layoutStructMemberQualifierShaderTemplate % qualifier, True)
 421                                                 for qualifier in ["row_major", "column_major"]], [])
 422                         + createCases("struct_member_layout_all", layoutStructMemberQualifierShaderTemplate % "row_major, column_major", True)
 423                         + createCases("struct_member_layout_all_8_times", layoutStructMemberQualifierShaderTemplate % str.join(", ", ["row_major", "column_major"] * 8), True)
 424                         + createCases("long_block_name", longIdentifierBlockNameShaderTemplate, True)
 425                         + createCases("long_instance_name", longIdentifierInstanceNameShaderTemplate, True)
 426                         + createCases("underscore_block_name", underscoreIdentifierBlockNameShaderTemplate, True)
 427                         + createCases("underscore_instance_name", underscoreIdentifierInstanceNameShaderTemplate, True))
 428
 429 invalidMemberInterfaceQualifierShaderTemplate = """
 430 #version 300 es
 431 precision highp float;
 432
 433 ${{OUTPUT_DECLARATION}}
 434
 435 uniform UniformBlock
 436 {
 437         %s vec4 uniformMember;
 438 } uniformBlock;
 439
 440 void main()
 441 {
 442         ${{OUTPUT}} = uniformBlock.uniformMember;
 443 }"""[1:]
 444
 445 conflictingInstanceNamesShaderTemplate = """
 446 #version 300 es
 447 precision highp float;
 448
 449 ${{OUTPUT_DECLARATION}}
 450
 451 uniform UniformBlockA
 452 {
 453         vec4 uniformMember;
 454 } uniformBlock;
 455
 456 uniform UniformBlockB
 457 {
 458         vec4 uniformMember;
 459 } uniformBlock;
 460
 461 void main()
 462 {
 463         ${{OUTPUT}} = uniformBlock.uniformMember;
 464 }"""[1:]
 465
 466 conflictingFunctionAndInstanceNameShaderTemplate = """
 467 #version 300 es
 468 precision highp float;
 469
 470 ${{OUTPUT_DECLARATION}}
 471
 472 uniform UniformBlock
 473 {
 474         vec4 uniformMember;
 475 } uniformBlock;
 476
 477 float uniformBlock (float x)
 478 {
 479         return x;
 480 }
 481
 482 void main()
 483 {
 484         ${{OUTPUT}} = uniformBlock.uniformMember;
 485 }"""[1:]
 486
 487 conflictingFunctionAndBlockNameShaderTemplate = """
 488 #version 300 es
 489 precision highp float;
 490
 491 ${{OUTPUT_DECLARATION}}
 492
 493 uniform UniformBlock
 494 {
 495         vec4 uniformMember;
 496 } uniformBlock;
 497
 498 float UniformBlock (float x)
 499 {
 500         return x;
 501 }
 502
 503 void main()
 504 {
 505         ${{OUTPUT}} = uniformBlock.uniformMember;
 506 }"""[1:]
 507
 508 conflictingVariableAndInstanceNameShaderTemplate = """
 509 #version 300 es
 510 precision highp float;
 511
 512 ${{OUTPUT_DECLARATION}}
 513
 514 uniform UniformBlock
 515 {
 516         vec4 uniformMember;
 517 } uniformBlock;
 518
 519 %s vec4 uniformBlock;
 520
 521 void main()
 522 {
 523         ${{OUTPUT}} = uniformBlock.uniformMember;
 524 }"""[1:]
 525
 526 conflictingVariableAndBlockNameShaderTemplate = """
 527 #version 300 es
 528 precision highp float;
 529
 530 ${{OUTPUT_DECLARATION}}
 531
 532 uniform UniformBlock
 533 {
 534         vec4 uniformMember;
 535 } uniformBlock;
 536
 537 %s vec4 UniformBlock;
 538
 539 void main()
 540 {
 541         ${{OUTPUT}} = uniformBlock.uniformMember;
 542 }"""[1:]
 543
 544
 545 matchingInstanceAndBlockNameShaderTemplate = """
 546 #version 300 es
 547 precision highp float;
 548
 549 ${{OUTPUT_DECLARATION}}
 550
 551 uniform UniformBlock
 552 {
 553         vec4 uniformMember;
 554 } UniformBlock;
 555
 556 void main()
 557 {
 558         ${{OUTPUT}} = UniformBlock.uniformMember;
 559 }"""[1:]
 560
 561 referenceUsingBlockNameShaderTemplate = """
 562 #version 300 es
 563 precision highp float;
 564
 565 ${{OUTPUT_DECLARATION}}
 566
 567 uniform UniformBlock
 568 {
 569         vec4 uniformMember;
 570 } uniformBlock;
 571
 572 void main()
 573 {
 574         ${{OUTPUT}} = UniformBlock.uniformMember;
 575 }"""[1:]
 576
 577 emptyBlockShaderTemplate = """
 578 #version 300 es
 579 precision highp float;
 580
 581 ${{OUTPUT_DECLARATION}}
 582
 583 uniform UniformBlock
 584 {
 585 } uniformBlock;
 586
 587 void main()
 588 {
 589         ${{OUTPUT}} = vec4(0.0);
 590 }"""[1:]
 591
 592 emptyLayoutShaderTemplate = """
 593 #version 300 es
 594 precision highp float;
 595
 596 ${{OUTPUT_DECLARATION}}
 597
 598 layout() uniform UniformBlock
 599 {
 600         vec4 uniformMember;
 601 } uniformBlock;
 602
 603 void main()
 604 {
 605         ${{OUTPUT}} = uniformBlock.uniformMember;
 606 }"""[1:]
 607
 608 emptyGlobalLayoutShaderTemplate = """
 609 #version 300 es
 610 precision highp float;
 611
 612 layout() uniform;
 613
 614 ${{OUTPUT_DECLARATION}}
 615
 616 uniform UniformBlock
 617 {
 618         vec4 uniformMember;
 619 } uniformBlock;
 620
 621 void main()
 622 {
 623         ${{OUTPUT}} = uniformBlock.uniformMember;
 624 }"""[1:]
 625
 626 emptyMemberLayoutShaderTemplate = """
 627 #version 300 es
 628 precision highp float;
 629
 630 ${{OUTPUT_DECLARATION}}
 631
 632 uniform UniformBlock
 633 {
 634         layout() vec4 uniformMember;
 635 } uniformBlock;
 636
 637 void main()
 638 {
 639         ${{OUTPUT}} = uniformBlock.uniformMember;
 640 }"""[1:]
 641
 642 invalidMemberLayoutShaderTemplate = """
 643 #version 300 es
 644 precision highp float;
 645
 646 ${{OUTPUT_DECLARATION}}
 647
 648 uniform UniformBlock
 649 {
 650         layout(%s) vec4 uniformMember;
 651 } uniformBlock;
 652
 653 void main()
 654 {
 655         ${{OUTPUT}} = uniformBlock.uniformMember;
 656 }"""[1:]
 657
 658 structureDefinitionShaderTemplate = """
 659 #version 300 es
 660 precision highp float;
 661
 662 ${{OUTPUT_DECLARATION}}
 663
 664 uniform UniformBlock
 665 {
 666         struct A
 667         {
 668                 vec4 uniformMember;
 669         } a;
 670 } uniformBlock;
 671
 672 void main()
 673 {
 674         ${{OUTPUT}} = uniformBlock.a.uniformMember;
 675 }"""[1:]
 676
 677 samplerShaderTemplate = """
 678 #version 300 es
 679 precision highp float;
 680
 681 ${{OUTPUT_DECLARATION}}
 682
 683 uniform UniformBlock
 684 {
 685         sampler2D sampler;
 686         vec4 uniformMember;
 687 } uniformBlock;
 688
 689 void main()
 690 {
 691         ${{OUTPUT}} = uniformBlock.uniformMember;
 692 }"""[1:]
 693
 694 missingBlockNameShaderTemplate = """
 695 #version 300 es
 696 precision highp float;
 697
 698 ${{OUTPUT_DECLARATION}}
 699
 700 uniform
 701 {
 702         vec4 uniformMember;
 703 } uniformBlock;
 704
 705 void main()
 706 {
 707         ${{OUTPUT}} = uniformBlock.uniformMember;
 708 }"""[1:]
 709
 710 invalidNumberBlockNameShaderTemplate = """
 711 #version 300 es
 712 precision highp float;
 713
 714 ${{OUTPUT_DECLARATION}}
 715
 716 uniform 0UniformBlock
 717 {
 718         vec4 uniformMember;
 719 } uniformBlock;
 720
 721 void main()
 722 {
 723         ${{OUTPUT}} = uniformBlock.uniformMember;
 724 }"""[1:]
 725
 726 invalidHashBlockNameShaderTemplate = """
 727 #version 300 es
 728 precision highp float;
 729
 730 ${{OUTPUT_DECLARATION}}
 731
 732 uniform #UniformBlock
 733 {
 734         vec4 uniformMember;
 735 } uniformBlock;
 736
 737 void main()
 738 {
 739         ${{OUTPUT}} = uniformBlock.uniformMember;
 740 }"""[1:]
 741
 742 invalidDollarBlockNameShaderTemplate = """
 743 #version 300 es
 744 precision highp float;
 745
 746 ${{OUTPUT_DECLARATION}}
 747
 748 uniform $UniformBlock
 749 {
 750         vec4 uniformMember;
 751 } uniformBlock;
 752
 753 void main()
 754 {
 755         ${{OUTPUT}} = uniformBlock.uniformMember;
 756 }"""[1:]
 757
 758 invalidIdentifierBlockNameShaderTemplate = """
 759 #version 300 es
 760 precision highp float;
 761
 762 ${{OUTPUT_DECLARATION}}
 763
 764 uniform gl_UniformBlock
 765 {
 766         vec4 uniformMember;
 767 } uniformBlock;
 768
 769 void main()
 770 {
 771         ${{OUTPUT}} = uniformBlock.uniformMember;
 772 }"""[1:]
 773
 774 tooLongIdentifierBlockNameShaderTemplate = ("""
 775 #version 300 es
 776 precision highp float;
 777
 778 ${{OUTPUT_DECLARATION}}
 779
 780 // Total of 1025 characters
 781 uniform """ + ("a" * 1025) + """
 782 {
 783         vec4 uniformMember;
 784 } uniformBlock;
 785
 786 void main()
 787 {
 788         ${{OUTPUT}} = uniformBlock.uniformMember;
 789 }""")[1:]
 790
 791 invalidNumberInstanceNameShaderTemplate = """
 792 #version 300 es
 793 precision highp float;
 794
 795 ${{OUTPUT_DECLARATION}}
 796
 797 uniform UniformInstance
 798 {
 799         vec4 uniformMember;
 800 } 0uniformBlock;
 801
 802 void main()
 803 {
 804         ${{OUTPUT}} = 0uniformBlock.uniformMember;
 805 }"""[1:]
 806
 807 invalidHashInstanceNameShaderTemplate = """
 808 #version 300 es
 809 precision highp float;
 810
 811 ${{OUTPUT_DECLARATION}}
 812
 813 uniform UniformInstance
 814 {
 815         vec4 uniformMember;
 816 } #uniformBlock;
 817
 818 void main()
 819 {
 820         ${{OUTPUT}} = #uniformBlock.uniformMember;
 821 }"""[1:]
 822
 823 invalidDollarInstanceNameShaderTemplate = """
 824 #version 300 es
 825 precision highp float;
 826
 827 ${{OUTPUT_DECLARATION}}
 828
 829 uniform UniformInstance
 830 {
 831         vec4 uniformMember;
 832 } $uniformBlock;
 833
 834 void main()
 835 {
 836         ${{OUTPUT}} = $uniformBlock.uniformMember;
 837 }"""[1:]
 838
 839 invalidIdentifierInstanceNameShaderTemplate = """
 840 #version 300 es
 841 precision highp float;
 842
 843 ${{OUTPUT_DECLARATION}}
 844
 845 uniform UniformBlock
 846 {
 847         vec4 uniformMember;
 848 } gl_uniformBlock;
 849
 850 void main()
 851 {
 852         ${{OUTPUT}} = gl_uniformBlock.uniformMember;
 853 }"""[1:]
 854
 855 tooLongIdentifierInstanceNameShaderTemplate = ("""
 856 #version 300 es
 857 precision highp float;
 858
 859 ${{OUTPUT_DECLARATION}}
 860
 861 uniform UniformBlock
 862 {
 863         vec4 uniformMember;
 864 } """ + ("a" * 1025) + """;
 865 // Total of 1025 characters
 866
 867 void main()
 868 {
 869         ${{OUTPUT}} = """ + ("a" * 1025) + """.uniformMember;
 870 }""")[1:]
 871
 872 invalidCases = (
 873                         sum([createCases("member_%s_interface_qualifier" % qualifier, invalidMemberInterfaceQualifierShaderTemplate % qualifier, False)
 874                                         for qualifier in ["in", "out", "buffer", "attribute", "varying"]], [])
 875                         + createCases("conflicting_instance_names", conflictingInstanceNamesShaderTemplate, False)
 876                         + createCases("conflicting_function_and_instance_name", conflictingFunctionAndInstanceNameShaderTemplate, False)
 877                         + createCases("conflicting_function_and_block_name", conflictingFunctionAndBlockNameShaderTemplate, False)
 878                         + sum([createCases("conflicting_%s_and_instance_name" % qualifier, conflictingVariableAndInstanceNameShaderTemplate % qualifier, False)
 879                                         for qualifier in ["uniform", "in", "out"]], [])
 880                         + sum([createCases("conflicting_%s_and_block_name" % qualifier, conflictingVariableAndBlockNameShaderTemplate % qualifier, False)
 881                                         for qualifier in ["uniform", "in", "out"]], [])
 882                         + createCases("matching_instance_and_block_name", matchingInstanceAndBlockNameShaderTemplate, False)
 883                         + createCases("reference_using_block_name", referenceUsingBlockNameShaderTemplate, False)
 884                         + createCases("empty_block", emptyBlockShaderTemplate, False)
 885                         + createCases("empty_layout", emptyLayoutShaderTemplate, False)
 886                         + createCases("empty_member_layout", emptyMemberLayoutShaderTemplate, False)
 887                         + createCases("empty_global_layout", emptyGlobalLayoutShaderTemplate, False)
 888                         + createCases("structure_definition", structureDefinitionShaderTemplate, False)
 889                         + sum([createCases("member_layout_%s" % qualifier, invalidMemberLayoutShaderTemplate % qualifier, False)
 890                                         for qualifier in ["shared", "packed", "std140"]], [])
 891                         + createCases("missing_block_name", missingBlockNameShaderTemplate, False)
 892                         + createCases("invalid_number_block_name", invalidNumberBlockNameShaderTemplate, False)
 893                         + createCases("invalid_hash_block_name", invalidHashBlockNameShaderTemplate, False)
 894                         + createCases("invalid_dollar_block_name", invalidDollarBlockNameShaderTemplate, False)
 895                         + createCases("invalid_identifier_block_name", invalidIdentifierBlockNameShaderTemplate, False)
 896                         + createCases("too_long_block_name", tooLongIdentifierBlockNameShaderTemplate, False)
 897                         + createCases("invalid_number_instance_name", invalidNumberInstanceNameShaderTemplate, False)
 898                         + createCases("invalid_hash_instance_name", invalidDollarInstanceNameShaderTemplate, False)
 899                         + createCases("invalid_dollar_instance_name", invalidDollarInstanceNameShaderTemplate, False)
 900                         + createCases("invalid_identifier_instance_name", invalidIdentifierInstanceNameShaderTemplate, False)
 901                         + createCases("repeated_block", repeatedBlockShaderTemplate, False)
 902                         + createCases("repeated_block_no_instance_name", repeatedBlockNoInstanceNameShaderTemplate, False)
 903                 )
 904
 905 allCases.append(CaseGroup("valid", "Valid uniform interface block syntax tests.", validCases))
 906 allCases.append(CaseGroup("invalid", "Invalid uniform interface block syntax tests.", invalidCases))
 907
 908 if __name__ == "__main__":
 909         print "Generating shader case files."
 910         writeAllCases("uniform_block.test", allCases)