data/gles2/shaders/linkage.test

   1 # not declared in vertex shader, declared in fragment shader
   2 case varying_1
   3         desc "varying declared in fragment shader, no reference in vertex shader"
   4         values { output float out0 = 1.0; }
   5         vertex ""
   6                 ${VERTEX_DECLARATIONS}
   7                 void main()
   8                 {
   9                         ${VERTEX_OUTPUT}
  10                 }
  11         ""
  12         fragment ""
  13                 precision mediump float;
  14                 varying mediump float var;
  15                 ${FRAGMENT_DECLARATIONS}
  16                 void main()
  17                 {
  18                         out0 = 1.0;
  19                         ${FRAGMENT_OUTPUT}
  20                 }
  21         ""
  22 end
  23
  24 # declared in vertex shader, no reference in frag shader
  25 case varying_2
  26         desc "varying declared in vertex shader, no reference in fragment shader"
  27         vertex ""
  28                 ${VERTEX_DECLARATIONS}
  29                 varying mediump float var;
  30                 void main()
  31                 {
  32                         ${VERTEX_OUTPUT}
  33                 }
  34         ""
  35         fragment ""
  36                 void main()
  37                 {
  38                         gl_FragColor = vec4(1.0);
  39                 }
  40         ""
  41 end
  42
  43 # declared in vertex shader, declared in frag shader
  44 case varying_3
  45         desc "varying declared in both vertex and fragment shader, but not used"
  46         vertex ""
  47                 ${VERTEX_DECLARATIONS}
  48                 varying mediump float var;
  49                 void main()
  50                 {
  51                         ${VERTEX_OUTPUT}
  52                 }
  53         ""
  54         fragment ""
  55                 varying mediump float var;
  56                 void main()
  57                 {
  58                         gl_FragColor = vec4(1.0);
  59                 }
  60         ""
  61 end
  62
  63 # declared in vertex shader, static use in frag shader
  64 case varying_4
  65         desc "varying declared in both shaders, statically used in fragment shader"
  66         values { uniform bool u_false = false; }
  67         vertex ""
  68                 ${VERTEX_DECLARATIONS}
  69                 varying mediump float var;
  70                 void main()
  71                 {
  72                         ${VERTEX_OUTPUT}
  73                 }
  74         ""
  75         fragment ""
  76                 varying mediump float var;
  77                 uniform bool u_false;
  78                 void main()
  79                 {
  80                         if (u_false)
  81                                 gl_FragColor = vec4(var);
  82                         else
  83                                 gl_FragColor = vec4(1.0);
  84                 }
  85         ""
  86 end
  87
  88 # static use in vertex shader, no reference in fragment shader
  89 case varying_5
  90         desc "varying declared and statically used in vertex shader, no reference in fragment shader"
  91         values { uniform bool u_false = false; }
  92         vertex ""
  93                 ${VERTEX_DECLARATIONS}
  94                 varying mediump float var;
  95                 void main()
  96                 {
  97                         if (u_false)
  98                                 var = 1.0;
  99                         ${VERTEX_OUTPUT}
 100                 }
 101         ""
 102         fragment ""
 103                 void main()
 104                 {
 105                         gl_FragColor = vec4(1.0);
 106                 }
 107         ""
 108 end
 109
 110 # static use in vertex shader, declared in fragment shader
 111 case varying_6
 112         desc "varying declared and statically used in vertex shader, only declared in fragment shader"
 113         values { uniform bool u_false = false; }
 114         vertex ""
 115                 ${VERTEX_DECLARATIONS}
 116                 varying mediump float var;
 117                 void main()
 118                 {
 119                         if (u_false)
 120                                 var = 1.0;
 121                         ${VERTEX_OUTPUT}
 122                 }
 123         ""
 124         fragment ""
 125                 varying mediump float var;
 126                 void main()
 127                 {
 128                         gl_FragColor = vec4(1.0);
 129                 }
 130         ""
 131 end
 132
 133 # static use in vertex shader, used in fragment shader
 134 case varying_7
 135         desc "varying statically used in both vertex and fragment shader"
 136         values { uniform bool u_false = false; }
 137         vertex ""
 138                 ${VERTEX_DECLARATIONS}
 139                 varying mediump float var;
 140                 void main()
 141                 {
 142                         if (u_false)
 143                                 var = 1.0;
 144                         ${VERTEX_OUTPUT}
 145                 }
 146         ""
 147         fragment ""
 148                 ${FRAGMENT_DECLARATIONS}
 149                 varying mediump float var;
 150                 void main()
 151                 {
 152                         if (u_false)
 153                                 gl_FragColor = vec4(var);
 154                         else
 155                                 gl_FragColor = vec4(1.0);
 156                 }
 157         ""
 158 end
 159
 160 case varying_type_float
 161         desc "varying of type float"
 162         values
 163         {
 164                 input float in0         = [ -1.25 | -25.65 | 1.0 | 2.25 | 3.4 | 16.0 ];
 165                 output float out0       = [ -1.25 | -25.65 | 1.0 | 2.25 | 3.4 | 16.0 ];
 166         }
 167         vertex ""
 168                 ${VERTEX_DECLARATIONS}
 169                 varying mediump float var;
 170                 void main()
 171                 {
 172                         var = in0;
 173                         ${VERTEX_OUTPUT}
 174                 }
 175         ""
 176         fragment ""
 177                 precision mediump float;
 178                 ${FRAGMENT_DECLARATIONS}
 179                 varying float var;
 180                 void main()
 181                 {
 182                         out0 = var;
 183                         ${FRAGMENT_OUTPUT}
 184                 }
 185         ""
 186 end
 187
 188 case varying_type_vec2
 189         desc "varying of type vec2"
 190         values
 191         {
 192                 input vec2 in0          = [ vec2(-1.25, 1.25) | vec2(-25.65, -7.25) | vec2(0.0, 1.0) | vec2(2.25, 2.25) | vec2(3.4, 9.5) | vec2(16.0, 32.0) ];
 193                 output vec2 out0        = [ vec2(-1.25, 1.25) | vec2(-25.65, -7.25) | vec2(0.0, 1.0) | vec2(2.25, 2.25) | vec2(3.4, 9.5) | vec2(16.0, 32.0) ];
 194         }
 195         vertex ""
 196                 ${VERTEX_DECLARATIONS}
 197                 varying mediump vec2 var;
 198                 void main()
 199                 {
 200                         var = in0;
 201                         ${VERTEX_OUTPUT}
 202                 }
 203         ""
 204         fragment ""
 205                 precision mediump float;
 206                 ${FRAGMENT_DECLARATIONS}
 207                 varying vec2 var;
 208                 void main()
 209                 {
 210                         out0 = var;
 211                         ${FRAGMENT_OUTPUT}
 212                 }
 213         ""
 214 end
 215
 216 case varying_type_vec3
 217         desc "varying of type vec3"
 218         values
 219         {
 220                 input vec3 in0          = [ vec3(-1.25, 1.25, -9.5) | vec3(-25.65, -7.25, 14.21) | vec3(0.0, 1.0, -1.0) | vec3(2.25, 2.25, 22.5) | vec3(3.4, 9.5, 19.5) | vec3(16.0, 32.0, -64.0) ];
 221                 output vec3 out0        = [ vec3(-1.25, 1.25, -9.5) | vec3(-25.65, -7.25, 14.21) | vec3(0.0, 1.0, -1.0) | vec3(2.25, 2.25, 22.5) | vec3(3.4, 9.5, 19.5) | vec3(16.0, 32.0, -64.0) ];
 222         }
 223         vertex ""
 224                 ${VERTEX_DECLARATIONS}
 225                 varying mediump vec3 var;
 226                 void main()
 227                 {
 228                         var = in0;
 229                         ${VERTEX_OUTPUT}
 230                 }
 231         ""
 232         fragment ""
 233                 precision mediump float;
 234                 ${FRAGMENT_DECLARATIONS}
 235                 varying vec3 var;
 236                 void main()
 237                 {
 238                         out0 = var;
 239                         ${FRAGMENT_OUTPUT}
 240                 }
 241         ""
 242 end
 243
 244 case varying_type_vec4
 245         desc "varying of type vec4"
 246         values
 247         {
 248                 input vec4 in0          = [ vec4(-1.25, 1.25, -9.5, -12.2) | vec4(-25.65, -7.25, 14.21, -77.7) | vec4(0.0, 1.0, -1.0, 2.0) | vec4(2.25, 2.25, 22.5, 225.0) | vec4(3.4, 9.5, 19.5, 29.5) | vec4(16.0, 32.0, -64.0, -128.0) ];
 249                 output vec4 out0        = [ vec4(-1.25, 1.25, -9.5, -12.2) | vec4(-25.65, -7.25, 14.21, -77.7) | vec4(0.0, 1.0, -1.0, 2.0) | vec4(2.25, 2.25, 22.5, 225.0) | vec4(3.4, 9.5, 19.5, 29.5) | vec4(16.0, 32.0, -64.0, -128.0) ];
 250         }
 251         vertex ""
 252                 ${VERTEX_DECLARATIONS}
 253                 varying mediump vec4 var;
 254                 void main()
 255                 {
 256                         var = in0;
 257                         ${VERTEX_OUTPUT}
 258                 }
 259         ""
 260         fragment ""
 261                 precision mediump float;
 262                 ${FRAGMENT_DECLARATIONS}
 263                 varying vec4 var;
 264                 void main()
 265                 {
 266                         out0 = var;
 267                         ${FRAGMENT_OUTPUT}
 268                 }
 269         ""
 270 end
 271
 272 case varying_type_mat2
 273         desc "varying of type mat2"
 274         values
 275         {
 276                 input mat2 in0          = [ mat2(1.0, 1.0, 1.0, 1.0) | mat2(-1.25, 1.25, -9.5, -12.2) | mat2(-25.65, -7.25, 14.21, -77.7) | mat2(0.0, 1.0, -1.0, 2.0) | mat2(2.25, 2.25, 22.5, 225.0) | mat2(3.4, 9.5, 19.5, 29.5) | mat2(16.0, 32.0, -64.0, -128.0) ];
 277                 output mat2 out0        = [ mat2(1.0, 1.0, 1.0, 1.0) | mat2(-1.25, 1.25, -9.5, -12.2) | mat2(-25.65, -7.25, 14.21, -77.7) | mat2(0.0, 1.0, -1.0, 2.0) | mat2(2.25, 2.25, 22.5, 225.0) | mat2(3.4, 9.5, 19.5, 29.5) | mat2(16.0, 32.0, -64.0, -128.0) ];
 278         }
 279         vertex ""
 280                 ${VERTEX_DECLARATIONS}
 281                 varying mediump mat2 var;
 282                 void main()
 283                 {
 284                         var = in0;
 285                         ${VERTEX_OUTPUT}
 286                 }
 287         ""
 288         fragment ""
 289                 precision mediump float;
 290                 ${FRAGMENT_DECLARATIONS}
 291                 varying mat2 var;
 292                 void main()
 293                 {
 294                         out0 = var;
 295                         ${FRAGMENT_OUTPUT}
 296                 }
 297         ""
 298 end
 299
 300 case varying_type_mat3
 301         desc "varying of type mat3"
 302         values
 303         {
 304                 input mat3 in0          = [ mat3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 9.9) | mat3(0.0, 1.0, -1.0, 2.0, 2.25, 2.25, 22.5, 225.0, -9.9) | mat3(3.4, 9.5, 19.5, 29.5, 16.0, 32.0, -64.0, -128.0, 256.0) ];
 305                 output mat3 out0        = [ mat3(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 9.9) | mat3(0.0, 1.0, -1.0, 2.0, 2.25, 2.25, 22.5, 225.0, -9.9) | mat3(3.4, 9.5, 19.5, 29.5, 16.0, 32.0, -64.0, -128.0, 256.0) ];
 306         }
 307         vertex ""
 308                 ${VERTEX_DECLARATIONS}
 309                 varying mediump mat3 var;
 310                 void main()
 311                 {
 312                         var = in0;
 313                         ${VERTEX_OUTPUT}
 314                 }
 315         ""
 316         fragment ""
 317                 precision mediump float;
 318                 ${FRAGMENT_DECLARATIONS}
 319                 varying mat3 var;
 320                 void main()
 321                 {
 322                         out0 = var;
 323                         ${FRAGMENT_OUTPUT}
 324                 }
 325         ""
 326 end
 327
 328 case varying_type_mat4
 329         desc "varying of type mat4"
 330         values
 331         {
 332                 input mat4 in0          = [ mat4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0, 2.25, 2.25, 22.5, 225.0) ];
 333                 output mat4 out0        = [ mat4(-1.25, 1.25, -9.5, -12.2, -25.65, -7.25, 14.21, -77.7, 0.0, 1.0, -1.0, 2.0, 2.25, 2.25, 22.5, 225.0) ];
 334         }
 335         vertex ""
 336                 ${VERTEX_DECLARATIONS}
 337                 varying mediump mat4 var;
 338                 void main()
 339                 {
 340                         var = in0;
 341                         ${VERTEX_OUTPUT}
 342                 }
 343         ""
 344         fragment ""
 345                 precision mediump float;
 346                 ${FRAGMENT_DECLARATIONS}
 347                 varying mat4 var;
 348                 void main()
 349                 {
 350                         out0 = var;
 351                         ${FRAGMENT_OUTPUT}
 352                 }
 353         ""
 354 end
 355
 356 # differing precision tests
 357 case varying_differing_precision_1
 358         desc "varying declared as highp in vertex shader, but mediump in fragment shader"
 359         values
 360         {
 361                 input float in0         = [ -1.25 | -25.55 | 1.0 | 2.25 | 3.4 | 16.0 ];
 362                 output float out0       = [ -1.25 | -25.55 | 1.0 | 2.25 | 3.4 | 16.0 ];
 363         }
 364
 365         vertex ""
 366                 ${VERTEX_DECLARATIONS}
 367                 varying highp float var;
 368                 void main()
 369                 {
 370                         var = in0;
 371                         ${VERTEX_OUTPUT}
 372                 }
 373         ""
 374         fragment ""
 375                 precision mediump float;
 376                 ${FRAGMENT_DECLARATIONS}
 377                 varying mediump float var;
 378                 void main()
 379                 {
 380                         out0 = var;
 381                         ${FRAGMENT_OUTPUT}
 382                 }
 383         ""
 384 end
 385
 386 # differing precision tests
 387 case varying_differing_precision_2
 388         desc "varying declared as highp in vertex shader, but lowp in fragment shader"
 389         values
 390         {
 391                 input float in0         = [ -1.25 | -25.56 | 1.0 | 2.25 | 3.4 | 16.0 ];
 392                 output float out0       = [ -1.25 | -25.56 | 1.0 | 2.25 | 3.4 | 16.0 ];
 393         }
 394
 395         vertex ""
 396                 ${VERTEX_DECLARATIONS}
 397                 varying highp vec2 var;
 398                 void main()
 399                 {
 400                         var = vec2(in0, 2.0*in0);
 401                         ${VERTEX_OUTPUT}
 402                 }
 403         ""
 404         fragment ""
 405                 precision mediump float;
 406                 ${FRAGMENT_DECLARATIONS}
 407                 varying lowp vec2 var;
 408                 void main()
 409                 {
 410                         out0 = var.y - var.x;
 411                         ${FRAGMENT_OUTPUT}
 412                 }
 413         ""
 414 end
 415
 416 # differing precision tests
 417 case varying_differing_precision_3
 418         desc "varying declared as lowp in vertex shader, but mediump in fragment shader"
 419         values
 420         {
 421                 input float in0         = [ -1.25 | -25.0 | 1.0 | 2.25 | 3.4 | 16.0 ];
 422                 output float out0       = [ -1.25 | -25.0 | 1.0 | 2.25 | 3.4 | 16.0 ];
 423         }
 424
 425         vertex ""
 426                 ${VERTEX_DECLARATIONS}
 427                 varying lowp vec4 var;
 428                 void main()
 429                 {
 430                         var = vec4(in0, 2.0*in0, -in0, -in0);
 431                         ${VERTEX_OUTPUT}
 432                 }
 433         ""
 434         fragment ""
 435                 precision mediump float;
 436                 ${FRAGMENT_DECLARATIONS}
 437                 varying mediump vec4 var;
 438                 void main()
 439                 {
 440                         out0 = var.x + var.y + var.z + var.w;
 441                         ${FRAGMENT_OUTPUT}
 442                 }
 443         ""
 444 end
 445
 446 # mismatched type, static use but no runtime use in the fragment shader
 447 case varying_type_mismatch_1
 448         desc "varying type mismatch (float vs. vec2), static use but no runtime use in the fragment shader"
 449         expect link_fail
 450         vertex ""
 451                 ${VERTEX_DECLARATIONS}
 452                 varying mediump float var;
 453                 void main()
 454                 {
 455                         var = 2.0;
 456                         ${VERTEX_OUTPUT}
 457                 }
 458         ""
 459         fragment ""
 460                 varying mediump vec2 var;
 461                 void main()
 462                 {
 463                         if (false)
 464                         {
 465                                 gl_FragColor = vec4(var.y);
 466                         }
 467                         else
 468                         {
 469                                 ${FRAG_COLOR} = vec4(1.0);
 470                         }
 471                 }
 472         ""
 473 end
 474
 475 # mismatched type, varyings used
 476 case varying_type_mismatch_2
 477         desc "varying type mismatch (float vs. vec2)"
 478         expect link_fail
 479         vertex ""
 480                 ${VERTEX_DECLARATIONS}
 481                 varying mediump float var;
 482                 void main()
 483                 {
 484                         var = 2.0;
 485                         ${VERTEX_OUTPUT}
 486                 }
 487         ""
 488         fragment ""
 489                 varying mediump vec2 var;
 490                 void main()
 491                 {
 492                         gl_FragColor = var.xyyx;
 493                 }
 494         ""
 495 end
 496
 497 # no declaration in vertex shader, but static use in fragment
 498 case varying_illegal_usage_1
 499         desc "varying not declared in vertex shader, but statically used in fragment shader"
 500         expect link_fail
 501         vertex ""
 502                 ${VERTEX_DECLARATIONS}
 503                 void main()
 504                 {
 505                         ${VERTEX_OUTPUT}
 506                 }
 507         ""
 508         fragment ""
 509                 varying mediump float var;
 510                 void main()
 511                 {
 512                         gl_FragColor = vec4(var);
 513                 }
 514         ""
 515 end
 516
 517 # integer varyings not allowed
 518 case invalid_varying_type_int
 519         desc "integer varying used"
 520         expect compile_fail
 521         vertex ""
 522                 ${VERTEX_DECLARATIONS}
 523                 varying mediump int var;
 524                 void main()
 525                 {
 526                         ${VERTEX_OUTPUT}
 527                 }
 528         ""
 529         fragment ""
 530                 varying mediump int var;
 531                 void main()
 532                 {
 533                         gl_FragColor = vec4(1.0);
 534                 }
 535         ""
 536 end
 537
 538 # bool varyings not allowed
 539 case invalid_varying_type_bool
 540         desc "boolean varying used"
 541         expect compile_fail
 542         vertex ""
 543                 ${VERTEX_DECLARATIONS}
 544                 varying bool var;
 545                 void main()
 546                 {
 547                         ${VERTEX_OUTPUT}
 548                 }
 549         ""
 550         fragment ""
 551                 varying bool var;
 552                 void main()
 553                 {
 554                         gl_FragColor = vec4(1.0);
 555                 }
 556         ""
 557 end
 558
 559 # struct varyings not allowed
 560 case invalid_varying_type_struct
 561         desc "struct varying used"
 562         expect compile_fail
 563         vertex ""
 564                 ${VERTEX_DECLARATIONS}
 565                 varying struct { mediump float foo; } var;
 566                 void main()
 567                 {
 568                         ${VERTEX_OUTPUT}
 569                 }
 570         ""
 571         fragment ""
 572                 varying struct { mediump float foo; } var;
 573                 void main()
 574                 {
 575                         gl_FragColor = vec4(1.0);
 576                 }
 577         ""
 578 end
 579
 580 case varying_readback_1
 581         desc "read back (an already written) varying in the vertex shader"
 582         values
 583         {
 584                 input float in0         = [ 1.0 | 0.0 | -2.0 | 10.0 ];
 585                 output float out0       = [ 3.0 | 0.0 | -6.0 | 30.0 ];
 586         }
 587         vertex ""
 588                 precision mediump float;
 589                 ${VERTEX_DECLARATIONS}
 590                 varying float var1;
 591                 varying float var2;
 592
 593                 void main()
 594                 {
 595                         var1 = in0;
 596                         var2 = var1 + in0;
 597                         ${VERTEX_OUTPUT}
 598                 }
 599         ""
 600         fragment ""
 601                 precision mediump float;
 602                 ${FRAGMENT_DECLARATIONS}
 603                 varying float var1;
 604                 varying float var2;
 605
 606                 void main()
 607                 {
 608                         out0 = var1 + var2;
 609                         ${FRAGMENT_OUTPUT}
 610                 }
 611         ""
 612 end
 613
 614 case varying_writeback_1
 615         desc "write back a varying in the fragment shader"
 616         expect compile_fail
 617         vertex ""
 618                 precision mediump float;
 619                 ${VERTEX_DECLARATIONS}
 620                 varying float var1;
 621                 varying float var2;
 622
 623                 void main()
 624                 {
 625                         var1 = in0;
 626                         var2 = var1 + in0;
 627                         ${VERTEX_OUTPUT}
 628                 }
 629         ""
 630         fragment ""
 631                 precision mediump float;
 632                 ${FRAGMENT_DECLARATIONS}
 633                 varying float var1;
 634                 varying float var2;
 635
 636                 void main()
 637                 {
 638                         var2 = var1;
 639                         out0 = var1;
 640                         ${FRAGMENT_OUTPUT}
 641                 }
 642         ""
 643 end
 644
 645 # Struct linkage handling
 646 case uniform_struct
 647         desc "Same uniform struct in both shaders"
 648         values {
 649                 uniform float val.a = 1.0;
 650                 uniform float val.b = 2.0;
 651                 output float out0 = 3.0;
 652         }
 653         vertex ""
 654                 ${VERTEX_DECLARATIONS}
 655                 struct Struct {mediump float a; mediump float b;};
 656                 uniform Struct val;
 657                 varying mediump float dummy;
 658                 void main()
 659                 {
 660                         dummy = val.a + val.b;
 661                         ${VERTEX_OUTPUT}
 662                 }
 663         ""
 664         fragment ""
 665             precision mediump float;
 666                 struct Struct {mediump float a; mediump float b;};
 667                 uniform Struct val;
 668                 varying mediump float dummy;
 669                 ${FRAGMENT_DECLARATIONS}
 670                 void main()
 671                 {
 672                         out0 = val.b + val.a;
 673                         out0 = out0 + dummy;
 674                         out0 = out0 - dummy;
 675                         ${FRAGMENT_OUTPUT}
 676                 }
 677         ""
 678 end
 679
 680 case uniform_struct_vertex_only
 681         desc "Uniform struct declared in both, used only in vertex."
 682         values {
 683                 uniform float val.a = 1.0;
 684                 uniform float val.b = 2.0;
 685                 output float out0 = 3.0;
 686         }
 687         vertex ""
 688                 ${VERTEX_DECLARATIONS}
 689                 struct Struct {mediump float a; mediump float b;};
 690                 uniform Struct val;
 691                 varying mediump float res;
 692                 void main()
 693                 {
 694                         res = val.a + val.b;
 695                         ${VERTEX_OUTPUT}
 696                 }
 697         ""
 698         fragment ""
 699             precision mediump float;
 700                 struct Struct {mediump float a; mediump float b;};
 701                 uniform Struct val;
 702                 varying mediump float res;
 703                 ${FRAGMENT_DECLARATIONS}
 704                 void main()
 705                 {
 706                         out0 = res;
 707                         ${FRAGMENT_OUTPUT}
 708                 }
 709         ""
 710 end
 711
 712 case uniform_struct_fragment_only
 713         desc "Uniform struct declared in both, used only in fragment."
 714         values {
 715                 uniform float val.a = 1.0;
 716                 uniform float val.b = 2.0;
 717                 output float out0 = 3.0;
 718         }
 719         vertex ""
 720                 ${VERTEX_DECLARATIONS}
 721                 struct Struct {mediump float a; mediump float b;};
 722                 uniform Struct val;
 723                 void main()
 724                 {
 725                         ${VERTEX_OUTPUT}
 726                 }
 727         ""
 728         fragment ""
 729             precision mediump float;
 730                 struct Struct {mediump float a; mediump float b;};
 731                 uniform Struct val;
 732                 ${FRAGMENT_DECLARATIONS}
 733                 void main()
 734                 {
 735                         out0 = val.a + val.b;
 736                         ${FRAGMENT_OUTPUT}
 737                 }
 738         ""
 739 end
 740
 741 case uniform_struct_partial
 742         desc "Uniform struct declared in both, used partially in both."
 743         values {
 744                 uniform float val.a = 1.0;
 745                 uniform float val.b = 2.0;
 746                 output float out0 = 3.0;
 747         }
 748         vertex ""
 749                 ${VERTEX_DECLARATIONS}
 750                 struct Struct {mediump float a; mediump float b;};
 751                 uniform Struct val;
 752                 varying mediump float res;
 753                 void main()
 754                 {
 755                         res = val.a;
 756                         ${VERTEX_OUTPUT}
 757                 }
 758         ""
 759         fragment ""
 760             precision mediump float;
 761                 struct Struct {mediump float a; mediump float b;};
 762                 uniform Struct val;
 763                 ${FRAGMENT_DECLARATIONS}
 764                 varying mediump float res;
 765                 void main()
 766                 {
 767                         out0 = res + val.b;
 768                         ${FRAGMENT_OUTPUT}
 769                 }
 770         ""
 771 end
 772
 773 case uniform_struct_vec4
 774         desc "Same uniform struct in both shaders. Datatype vec4"
 775         values {
 776                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 777                 uniform vec4 val.b = vec4(1.0, 2.0, 3.0, 4.0);
 778                 output float out0 = 3.0;
 779         }
 780         vertex ""
 781                 ${VERTEX_DECLARATIONS}
 782                 struct Struct {mediump vec4 a; mediump vec4 b;};
 783                 uniform Struct val;
 784                 varying mediump float dummy;
 785                 void main()
 786                 {
 787                         dummy = val.a.x + val.b.y;
 788                         ${VERTEX_OUTPUT}
 789                 }
 790         ""
 791         fragment ""
 792             precision mediump float;
 793                 struct Struct {mediump vec4 a; mediump vec4 b;};
 794                 uniform Struct val;
 795                 varying mediump float dummy;
 796                 ${FRAGMENT_DECLARATIONS}
 797                 void main()
 798                 {
 799                         out0 = val.b.y + val.a.x;
 800                         out0 = out0 + dummy;
 801                         out0 = out0 - dummy;
 802                         ${FRAGMENT_OUTPUT}
 803                 }
 804         ""
 805 end
 806
 807 case uniform_struct_vertex_only_vec4
 808         desc "Uniform struct declared in both, used only in vertex. Datatype vec4       "
 809         values {
 810                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 811                 uniform vec4 val.b = vec4(1.0, 2.0, 3.0, 4.0);
 812                 output float out0 = 3.0;
 813         }
 814         vertex ""
 815                 ${VERTEX_DECLARATIONS}
 816                 struct Struct {mediump vec4 a; mediump vec4 b;};
 817                 uniform Struct val;
 818                 varying mediump float res;
 819                 void main()
 820                 {
 821                         res = val.a.x + val.b.y;
 822                         ${VERTEX_OUTPUT}
 823                 }
 824         ""
 825         fragment ""
 826             precision mediump float;
 827                 struct Struct {mediump vec4 a; mediump vec4 b;};
 828                 uniform Struct val;
 829                 varying mediump float res;
 830                 ${FRAGMENT_DECLARATIONS}
 831                 void main()
 832                 {
 833                         out0 = res;
 834                         ${FRAGMENT_OUTPUT}
 835                 }
 836         ""
 837 end
 838
 839 case uniform_struct_fragment_only_vec4
 840         desc "Uniform struct declared in both, used only in fragment. Datatype vec4"
 841         values {
 842                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 843                 uniform vec4 val.b = vec4(1.0, 2.0, 3.0, 4.0);
 844                 output float out0 = 3.0;
 845         }
 846         vertex ""
 847                 ${VERTEX_DECLARATIONS}
 848                 struct Struct {mediump vec4 a; mediump vec4 b;};
 849                 uniform Struct val;
 850                 void main()
 851                 {
 852                         ${VERTEX_OUTPUT}
 853                 }
 854         ""
 855         fragment ""
 856             precision mediump float;
 857                 struct Struct {mediump vec4 a; mediump vec4 b;};
 858                 uniform Struct val;
 859                 ${FRAGMENT_DECLARATIONS}
 860                 void main()
 861                 {
 862                         out0 = val.a.x + val.b.y;
 863                         ${FRAGMENT_OUTPUT}
 864                 }
 865         ""
 866 end
 867
 868 case uniform_struct_partial_vec4
 869         desc "Uniform struct declared in both, used partially in both. Datatype vec4"
 870         values {
 871                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 872                 uniform vec4 val.b = vec4(1.0, 2.0, 3.0, 4.0);
 873                 output float out0 = 3.0;
 874         }
 875         vertex ""
 876                 ${VERTEX_DECLARATIONS}
 877                 struct Struct {mediump vec4 a; mediump vec4 b;};
 878                 uniform Struct val;
 879                 varying mediump float res;
 880                 void main()
 881                 {
 882                         res = val.a.x;
 883                         ${VERTEX_OUTPUT}
 884                 }
 885         ""
 886         fragment ""
 887             precision mediump float;
 888                 struct Struct {mediump vec4 a; mediump vec4 b;};
 889                 uniform Struct val;
 890                 ${FRAGMENT_DECLARATIONS}
 891                 varying mediump float res;
 892                 void main()
 893                 {
 894                         out0 = res + val.b.y;
 895                         ${FRAGMENT_OUTPUT}
 896                 }
 897         ""
 898 end
 899
 900 case uniform_struct_vec4_vec3
 901         desc "Same uniform struct in both shaders. Datatype vec4 and vec3"
 902         values {
 903                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 904                 uniform vec3 val.b = vec3(1.0, 2.0, 3.0);
 905                 output float out0 = 3.0;
 906         }
 907         vertex ""
 908                 ${VERTEX_DECLARATIONS}
 909                 struct Struct {mediump vec4 a; mediump vec3 b;};
 910                 uniform Struct val;
 911                 varying mediump float dummy;
 912                 void main()
 913                 {
 914                         dummy = val.a.x + val.b.y;
 915                         ${VERTEX_OUTPUT}
 916                 }
 917         ""
 918         fragment ""
 919             precision mediump float;
 920                 struct Struct {mediump vec4 a; mediump vec3 b;};
 921                 uniform Struct val;
 922                 varying mediump float dummy;
 923                 ${FRAGMENT_DECLARATIONS}
 924                 void main()
 925                 {
 926                         out0 = val.b.y + val.a.x;
 927                         out0 = out0 + dummy;
 928                         out0 = out0 - dummy;
 929                         ${FRAGMENT_OUTPUT}
 930                 }
 931         ""
 932 end
 933
 934 case uniform_struct_vertex_only_vec4_vec3
 935         desc "Uniform struct declared in both, used only in vertex. Datatype vec4 and vec3"
 936         values {
 937                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 938                 uniform vec3 val.b = vec3(1.0, 2.0, 3.0);
 939                 output float out0 = 3.0;
 940         }
 941         vertex ""
 942                 ${VERTEX_DECLARATIONS}
 943                 struct Struct {mediump vec4 a; mediump vec3 b;};
 944                 uniform Struct val;
 945                 varying mediump float res;
 946                 void main()
 947                 {
 948                         res = val.a.x + val.b.y;
 949                         ${VERTEX_OUTPUT}
 950                 }
 951         ""
 952         fragment ""
 953             precision mediump float;
 954                 struct Struct {mediump vec4 a; mediump vec3 b;};
 955                 uniform Struct val;
 956                 varying mediump float res;
 957                 ${FRAGMENT_DECLARATIONS}
 958                 void main()
 959                 {
 960                         out0 = res;
 961                         ${FRAGMENT_OUTPUT}
 962                 }
 963         ""
 964 end
 965
 966 case uniform_struct_fragment_only_vec4_vec3
 967         desc "Uniform struct declared in both, used only in fragment. Datatype vec4 and vec3"
 968         values {
 969                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 970                 uniform vec3 val.b = vec3(1.0, 2.0, 3.0);
 971                 output float out0 = 3.0;
 972         }
 973         vertex ""
 974                 ${VERTEX_DECLARATIONS}
 975                 struct Struct {mediump vec4 a; mediump vec3 b;};
 976                 uniform Struct val;
 977                 void main()
 978                 {
 979                         ${VERTEX_OUTPUT}
 980                 }
 981         ""
 982         fragment ""
 983             precision mediump float;
 984                 struct Struct {mediump vec4 a; mediump vec3 b;};
 985                 uniform Struct val;
 986                 ${FRAGMENT_DECLARATIONS}
 987                 void main()
 988                 {
 989                         out0 = val.a.x + val.b.y;
 990                         ${FRAGMENT_OUTPUT}
 991                 }
 992         ""
 993 end
 994
 995 case uniform_struct_partial_vec4_vec3
 996         desc "Uniform struct declared in both, used partially in both. Datatype vec4 and vec3"
 997         values {
 998                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
 999                 uniform vec3 val.b = vec3(1.0, 2.0, 3.0);
1000                 output float out0 = 3.0;
1001         }
1002         vertex ""
1003                 ${VERTEX_DECLARATIONS}
1004                 struct Struct {mediump vec4 a; mediump vec3 b;};
1005                 uniform Struct val;
1006                 varying mediump float res;
1007                 void main()
1008                 {
1009                         res = val.a.x;
1010                         ${VERTEX_OUTPUT}
1011                 }
1012         ""
1013         fragment ""
1014             precision mediump float;
1015                 struct Struct {mediump vec4 a; mediump vec3 b;};
1016                 uniform Struct val;
1017                 ${FRAGMENT_DECLARATIONS}
1018                 varying mediump float res;
1019                 void main()
1020                 {
1021                         out0 = res + val.b.y;
1022                         ${FRAGMENT_OUTPUT}
1023                 }
1024         ""
1025 end
1026
1027 case uniform_struct_vec4_float
1028         desc "Same uniform struct in both shaders. Datatype vec4 and float"
1029         values {
1030                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
1031                 uniform float val.b = 2.0;
1032                 output float out0 = 3.0;
1033         }
1034         vertex ""
1035                 ${VERTEX_DECLARATIONS}
1036                 struct Struct {mediump vec4 a; mediump float b;};
1037                 uniform Struct val;
1038                 varying mediump float dummy;
1039                 void main()
1040                 {
1041                         dummy = val.a.x + val.b;
1042                         ${VERTEX_OUTPUT}
1043                 }
1044         ""
1045         fragment ""
1046             precision mediump float;
1047                 struct Struct {mediump vec4 a; mediump float b;};
1048                 uniform Struct val;
1049                 varying mediump float dummy;
1050                 ${FRAGMENT_DECLARATIONS}
1051                 void main()
1052                 {
1053                         out0 = val.b + val.a.x;
1054                         out0 = out0 + dummy;
1055                         out0 = out0 - dummy;
1056                         ${FRAGMENT_OUTPUT}
1057                 }
1058         ""
1059 end
1060
1061 case uniform_struct_vertex_only_vec4_float
1062         desc "Uniform struct declared in both, used only in vertex. Datatype vec4 and float"
1063         values {
1064                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
1065                 uniform float val.b = 2.0;
1066                 output float out0 = 3.0;
1067         }
1068         vertex ""
1069                 ${VERTEX_DECLARATIONS}
1070                 struct Struct {mediump vec4 a; mediump float b;};
1071                 uniform Struct val;
1072                 varying mediump float res;
1073                 void main()
1074                 {
1075                         res = val.a.x + val.b;
1076                         ${VERTEX_OUTPUT}
1077                 }
1078         ""
1079         fragment ""
1080             precision mediump float;
1081                 struct Struct {mediump vec4 a; mediump float b;};
1082                 uniform Struct val;
1083                 varying mediump float res;
1084                 ${FRAGMENT_DECLARATIONS}
1085                 void main()
1086                 {
1087                         out0 = res;
1088                         ${FRAGMENT_OUTPUT}
1089                 }
1090         ""
1091 end
1092
1093 case uniform_struct_fragment_only_vec4_float
1094         desc "Uniform struct declared in both, used only in fragment. Datatype vec4 and float"
1095         values {
1096                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
1097                 uniform float val.b = 2.0;
1098                 output float out0 = 3.0;
1099         }
1100         vertex ""
1101                 ${VERTEX_DECLARATIONS}
1102                 struct Struct {mediump vec4 a; mediump float b;};
1103                 uniform Struct val;
1104                 void main()
1105                 {
1106                         ${VERTEX_OUTPUT}
1107                 }
1108         ""
1109         fragment ""
1110             precision mediump float;
1111                 struct Struct {mediump vec4 a; mediump float b;};
1112                 uniform Struct val;
1113                 ${FRAGMENT_DECLARATIONS}
1114                 void main()
1115                 {
1116                         out0 = val.a.x + val.b;
1117                         ${FRAGMENT_OUTPUT}
1118                 }
1119         ""
1120 end
1121
1122 case uniform_struct_partial_vec4_float
1123         desc "Uniform struct declared in both, used partially in both. Datatype vec4 and float"
1124         values {
1125                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
1126                 uniform float val.b = 2.0;
1127                 output float out0 = 3.0;
1128         }
1129         vertex ""
1130                 ${VERTEX_DECLARATIONS}
1131                 struct Struct {mediump vec4 a; mediump float b;};
1132                 uniform Struct val;
1133                 varying mediump float res;
1134                 void main()
1135                 {
1136                         res = val.a.x;
1137                         ${VERTEX_OUTPUT}
1138                 }
1139         ""
1140         fragment ""
1141             precision mediump float;
1142                 struct Struct {mediump vec4 a; mediump float b;};
1143                 uniform Struct val;
1144                 ${FRAGMENT_DECLARATIONS}
1145                 varying mediump float res;
1146                 void main()
1147                 {
1148                         out0 = res + val.b;
1149                         ${FRAGMENT_OUTPUT}
1150                 }
1151         ""
1152 end
1153
1154 case uniform_struct_partial_vec4_struct
1155         desc "Uniform struct declared in both, used partially in both. Datatype vec4 and struct with vec4"
1156         values {
1157                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
1158                 uniform vec4 val.b.c = vec4(1.0, 2.0, 3.0, 4.0);
1159                 output float out0 = 3.0;
1160         }
1161         vertex ""
1162                 ${VERTEX_DECLARATIONS}
1163                 struct Inner {mediump vec4 c;};
1164                 struct Struct {mediump vec4 a; Inner b;};
1165                 uniform Struct val;
1166                 varying mediump float res;
1167                 void main()
1168                 {
1169                         res = val.a.x;
1170                         ${VERTEX_OUTPUT}
1171                 }
1172         ""
1173         fragment ""
1174             precision mediump float;
1175                 struct Inner {mediump vec4 c;};
1176                 struct Struct {mediump vec4 a; Inner b;};
1177                 uniform Struct val;
1178                 ${FRAGMENT_DECLARATIONS}
1179                 varying mediump float res;
1180                 void main()
1181                 {
1182                         out0 = res + val.b.c.y;
1183                         ${FRAGMENT_OUTPUT}
1184                 }
1185         ""
1186 end
1187
1188
1189
1190 case uniform_struct_partial_vec4_vec3_struct
1191         desc "Uniform struct declared in both, used partially in both. Datatype vec4 and struct with vec3"
1192         values {
1193                 uniform vec4 val.a = vec4(1.0, 2.0, 3.0, 4.0);
1194                 uniform vec3 val.b.c = vec3(1.0, 2.0, 3.0);
1195                 output float out0 = 3.0;
1196         }
1197         vertex ""
1198                 ${VERTEX_DECLARATIONS}
1199                 struct Inner {mediump vec3 c;};
1200                 struct Struct {mediump vec4 a; Inner b;};
1201                 uniform Struct val;
1202                 varying mediump float res;
1203                 void main()
1204                 {
1205                         res = val.a.x;
1206                         ${VERTEX_OUTPUT}
1207                 }
1208         ""
1209         fragment ""
1210             precision mediump float;
1211                 struct Inner {mediump vec3 c;};
1212                 struct Struct {mediump vec4 a; Inner b;};
1213                 uniform Struct val;
1214                 ${FRAGMENT_DECLARATIONS}
1215                 varying mediump float res;
1216                 void main()
1217                 {
1218                         out0 = res + val.b.c.y;
1219                         ${FRAGMENT_OUTPUT}
1220                 }
1221         ""
1222 end
1223
1224 case uniform_struct_partial_vec2_vec3
1225         desc "Uniform struct declared in both, used partially in both. Datatype vec2 and vec3"
1226         values {
1227                 uniform vec2 val.a = vec2(1.0, 2.0);
1228                 uniform vec3 val.b = vec3(1.0, 2.0, 3.0);
1229                 output float out0 = 3.0;
1230         }
1231         vertex ""
1232                 ${VERTEX_DECLARATIONS}
1233                 struct Struct {mediump vec2 a; mediump vec3 b;};
1234                 uniform Struct val;
1235                 varying mediump float res;
1236                 void main()
1237                 {
1238                         res = val.a.x;
1239                         ${VERTEX_OUTPUT}
1240                 }
1241         ""
1242         fragment ""
1243             precision mediump float;
1244                 struct Struct {mediump vec2 a; mediump vec3 b;};
1245                 uniform Struct val;
1246                 ${FRAGMENT_DECLARATIONS}
1247                 varying mediump float res;
1248                 void main()
1249                 {
1250                         out0 = res + val.b.y;
1251                         ${FRAGMENT_OUTPUT}
1252                 }
1253         ""
1254 end
1255
1256 case uniform_struct_partial_vec2_int
1257         desc "Uniform struct declared in both, used partially in both. Datatype vec2 and int"
1258         values {
1259                 uniform vec2 val.a = vec2(1.0, 2.0);
1260                 uniform int val.b = 2;
1261                 output float out0 = 3.0;
1262         }
1263         vertex ""
1264                 ${VERTEX_DECLARATIONS}
1265                 struct Struct {mediump vec2 a; mediump int b;};
1266                 uniform Struct val;
1267                 varying mediump float res;
1268                 void main()
1269                 {
1270                         res = val.a.x;
1271                         ${VERTEX_OUTPUT}
1272                 }
1273         ""
1274         fragment ""
1275             precision mediump float;
1276                 struct Struct {mediump vec2 a; mediump int b;};
1277                 uniform Struct val;
1278                 ${FRAGMENT_DECLARATIONS}
1279                 varying mediump float res;
1280                 void main()
1281                 {
1282                         out0 = res + float(val.b);
1283                         ${FRAGMENT_OUTPUT}
1284                 }
1285         ""
1286 end
1287
1288 case uniform_struct_partial_int_float
1289         desc "Uniform struct declared in both, used partially in both. Datatype int and float"
1290         values {
1291                 uniform float val.a = 1.0;
1292                 uniform int val.b = 2;
1293                 output float out0 = 3.0;
1294         }
1295         vertex ""
1296                 ${VERTEX_DECLARATIONS}
1297                 struct Struct {mediump float a; mediump int b;};
1298                 uniform Struct val;
1299                 varying mediump float res;
1300                 void main()
1301                 {
1302                         res = val.a;
1303                         ${VERTEX_OUTPUT}
1304                 }
1305         ""
1306         fragment ""
1307             precision mediump float;
1308                 struct Struct {mediump float a; mediump int b;};
1309                 uniform Struct val;
1310                 ${FRAGMENT_DECLARATIONS}
1311                 varying mediump float res;
1312                 void main()
1313                 {
1314                         out0 = res + float(val.b);
1315                         ${FRAGMENT_OUTPUT}
1316                 }
1317         ""
1318 end
1319
1320 case uniform_struct_partial_bvec2_vec2
1321         desc "Uniform struct declared in both, used partially in both. Datatype bvec2 and vec2"
1322         values {
1323                 uniform bvec2 val.a = bvec2(true, true);
1324                 uniform vec2 val.b = vec2(1.0, 2.0);
1325                 output float out0 = 3.0;
1326         }
1327         vertex ""
1328                 ${VERTEX_DECLARATIONS}
1329                 struct Struct {bvec2 a; mediump vec2 b;};
1330                 uniform Struct val;
1331                 varying mediump float res;
1332                 void main()
1333                 {
1334                         res = float(val.a.x);
1335                         ${VERTEX_OUTPUT}
1336                 }
1337         ""
1338         fragment ""
1339             precision mediump float;
1340                 struct Struct {bvec2 a; mediump vec2 b;};
1341                 uniform Struct val;
1342                 ${FRAGMENT_DECLARATIONS}
1343                 varying mediump float res;
1344                 void main()
1345                 {
1346                         out0 = res + val.b.y;
1347                         ${FRAGMENT_OUTPUT}
1348                 }
1349         ""
1350 end
1351
1352 case uniform_struct_partial_ivec2_vec2
1353         desc "Uniform struct declared in both, used partially in both. Datatype ivec2 and vec2"
1354         values {
1355                 uniform ivec2 val.a = ivec2(1, 2);
1356                 uniform vec2 val.b = vec2(1.0, 2.0);
1357                 output float out0 = 3.0;
1358         }
1359         vertex ""
1360                 ${VERTEX_DECLARATIONS}
1361                 struct Struct {mediump ivec2 a; mediump vec2 b;};
1362                 uniform Struct val;
1363                 varying mediump float res;
1364                 void main()
1365                 {
1366                         res = vec2(val.a).x;
1367                         ${VERTEX_OUTPUT}
1368                 }
1369         ""
1370         fragment ""
1371             precision mediump float;
1372                 struct Struct {mediump ivec2 a; mediump vec2 b;};
1373                 uniform Struct val;
1374                 ${FRAGMENT_DECLARATIONS}
1375                 varying mediump float res;
1376                 void main()
1377                 {
1378                         out0 = res + val.b.y;
1379                         ${FRAGMENT_OUTPUT}
1380                 }
1381         ""
1382 end
1383
1384 case uniform_struct_partial_ivec2_ivec2
1385         desc "Uniform struct declared in both, used partially in both. Datatype ivec2 and ivec2"
1386         values {
1387                 uniform ivec2 val.a = ivec2(1, 2);
1388                 uniform ivec2 val.b = ivec2(1, 2);
1389                 output float out0 = 3.0;
1390         }
1391         vertex ""
1392                 ${VERTEX_DECLARATIONS}
1393                 struct Struct {mediump ivec2 a; mediump ivec2 b;};
1394                 uniform Struct val;
1395                 varying mediump float res;
1396                 void main()
1397                 {
1398                         res = vec2(val.a).x;
1399                         ${VERTEX_OUTPUT}
1400                 }
1401         ""
1402         fragment ""
1403             precision mediump float;
1404                 struct Struct {mediump ivec2 a; mediump ivec2 b;};
1405                 uniform Struct val;
1406                 ${FRAGMENT_DECLARATIONS}
1407                 varying mediump float res;
1408                 void main()
1409                 {
1410                         out0 = res + vec2(val.b).y;
1411                         ${FRAGMENT_OUTPUT}
1412                 }
1413         ""
1414 end
1415
1416 case uniform_struct_type_conflict_1
1417         desc "Fragment struct has one less member than fragment version"
1418         expect link_fail
1419         values {output float out0 = 3.0;}
1420         vertex ""
1421                 ${VERTEX_DECLARATIONS}
1422                 struct Struct {mediump float a; mediump float b;};
1423                 uniform Struct val;
1424                 varying mediump float res;
1425                 void main()
1426                 {
1427                         res = val.a;
1428                         ${VERTEX_OUTPUT}
1429                 }
1430         ""
1431         fragment ""
1432             precision mediump float;
1433                 struct Struct {mediump float a;};
1434                 uniform Struct val;
1435                 ${FRAGMENT_DECLARATIONS}
1436                 varying mediump float res;
1437                 void main()
1438                 {
1439                         out0 = res + val.a;
1440                         ${FRAGMENT_OUTPUT}
1441                 }
1442         ""
1443 end
1444
1445 case uniform_struct_type_conflict_2
1446         desc "Vertex struct has int, fragment struct has float."
1447         expect link_fail
1448         values {output float out0 = 3.0;}
1449         vertex ""
1450                 ${VERTEX_DECLARATIONS}
1451                 struct Struct {mediump int a;};
1452                 uniform Struct val;
1453                 varying mediump float res;
1454                 void main()
1455                 {
1456                         res = float(val.a);
1457                         ${VERTEX_OUTPUT}
1458                 }
1459         ""
1460         fragment ""
1461             precision mediump float;
1462                 struct Struct {mediump float a;};
1463                 uniform Struct val;
1464                 ${FRAGMENT_DECLARATIONS}
1465                 varying mediump float res;
1466                 void main()
1467                 {
1468                         out0 = val.a;
1469                         ${FRAGMENT_OUTPUT}
1470                 }
1471         ""
1472 end
1473
1474 case uniform_struct_type_conflict_3
1475         desc "Vertex struct has vec3, fragment struct has vec4."
1476         expect link_fail
1477         values {output float out0 = 3.0;}
1478         vertex ""
1479                 ${VERTEX_DECLARATIONS}
1480                 struct Struct {mediump vec3 a;};
1481                 uniform Struct val;
1482                 varying mediump float res;
1483                 void main()
1484                 {
1485                         res = float(val.a.x);
1486                         ${VERTEX_OUTPUT}
1487                 }
1488         ""
1489         fragment ""
1490             precision mediump float;
1491                 struct Struct {mediump vec4 a;};
1492                 uniform Struct val;
1493                 ${FRAGMENT_DECLARATIONS}
1494                 varying mediump float res;
1495                 void main()
1496                 {
1497                         out0 = val.a.x;
1498                         ${FRAGMENT_OUTPUT}
1499                 }
1500         ""
1501 end
1502
1503 case uniform_struct_precision_conflict_1
1504         desc "Vertex side struct has highp, fragment side struct mediump."
1505         expect link_fail
1506         values {output float out0 = 3.0;}
1507         vertex ""
1508                 ${VERTEX_DECLARATIONS}
1509                 struct Struct {highp float a;};
1510                 uniform Struct val;
1511                 varying mediump float res;
1512                 void main()
1513                 {
1514                         res = val.a;
1515                         ${VERTEX_OUTPUT}
1516                 }
1517         ""
1518         fragment ""
1519             precision mediump float;
1520                 struct Struct {mediump float a;};
1521                 uniform Struct val;
1522                 ${FRAGMENT_DECLARATIONS}
1523                 varying mediump float res;
1524                 void main()
1525                 {
1526                         out0 = val.a;
1527                         ${FRAGMENT_OUTPUT}
1528                 }
1529         ""
1530 end
1531
1532 case uniform_struct_precision_conflict_2
1533         desc "Vertex side struct has mediump, fragment side struct lowp."
1534         expect link_fail
1535         values {output float out0 = 3.0;}
1536         vertex ""
1537                 ${VERTEX_DECLARATIONS}
1538                 struct Struct {mediump float a;};
1539                 uniform Struct val;
1540                 varying mediump float res;
1541                 void main()
1542                 {
1543                         res = val.a;
1544                         ${VERTEX_OUTPUT}
1545                 }
1546         ""
1547         fragment ""
1548             precision mediump float;
1549                 struct Struct {lowp float a;};
1550                 uniform Struct val;
1551                 ${FRAGMENT_DECLARATIONS}
1552                 varying mediump float res;
1553                 void main()
1554                 {
1555                         out0 = val.a;
1556                         ${FRAGMENT_OUTPUT}
1557                 }
1558         ""
1559 end
1560
1561 case uniform_struct_precision_conflict_3
1562         desc "Vertex side struct has lowp, fragment side struct mediump."
1563         expect link_fail
1564         values {output float out0 = 3.0;}
1565         vertex ""
1566                 ${VERTEX_DECLARATIONS}
1567                 struct Struct {lowp float a;};
1568                 uniform Struct val;
1569                 varying mediump float res;
1570                 void main()
1571                 {
1572                         res = val.a;
1573                         ${VERTEX_OUTPUT}
1574                 }
1575         ""
1576         fragment ""
1577             precision mediump float;
1578                 struct Struct {mediump float a;};
1579                 uniform Struct val;
1580                 ${FRAGMENT_DECLARATIONS}
1581                 varying mediump float res;
1582                 void main()
1583                 {
1584                         out0 = val.a;
1585                         ${FRAGMENT_OUTPUT}
1586                 }
1587         ""
1588 end
1589
1590 case uniform_struct_precision_conflict_4
1591         desc "Vertex side struct has lowp, fragment side struct implicit mediump."
1592         expect link_fail
1593         values {output float out0 = 3.0;}
1594         vertex ""
1595                 ${VERTEX_DECLARATIONS}
1596                 struct Struct {lowp float a;};
1597                 uniform Struct val;
1598                 varying mediump float res;
1599                 void main()
1600                 {
1601                         res = val.a;
1602                         ${VERTEX_OUTPUT}
1603                 }
1604         ""
1605         fragment ""
1606             precision mediump float;
1607                 struct Struct {float a;};
1608                 uniform Struct val;
1609                 ${FRAGMENT_DECLARATIONS}
1610                 varying mediump float res;
1611                 void main()
1612                 {
1613                         out0 = val.a;
1614                         ${FRAGMENT_OUTPUT}
1615                 }
1616         ""
1617 end
1618
1619 case uniform_struct_use_case_rip
1620         desc "Complex Light struct from use case tests."
1621         values {
1622                 uniform float val.constantAttenuation = 1.0;
1623                 uniform float val.quadraticAttenuation = 1.0;
1624             output float out0 = 2.0;
1625     }
1626         vertex ""
1627                  struct Light
1628                  {
1629                      mediump vec3       color;
1630                          highp vec4             position;
1631                          highp vec3             direction;
1632                          mediump float  constantAttenuation;
1633                          mediump float  linearAttenuation;
1634                          mediump float  quadraticAttenuation;
1635             };
1636                 ${VERTEX_DECLARATIONS}
1637                 uniform Light val;
1638                 varying mediump float res;
1639                 void main()
1640                 {
1641                         res = val.constantAttenuation;
1642                         ${VERTEX_OUTPUT}
1643                 }
1644         ""
1645         fragment ""
1646              precision mediump float;
1647                  struct Light
1648                  {
1649                      mediump vec3       color;
1650                          highp vec4             position;
1651                          highp vec3             direction;
1652                          mediump float  constantAttenuation;
1653                          mediump float  linearAttenuation;
1654                          mediump float  quadraticAttenuation;
1655             };
1656                 struct Struct {float a;};
1657                 uniform Light val;
1658                 ${FRAGMENT_DECLARATIONS}
1659                 varying mediump float res;
1660                 void main()
1661                 {
1662                         out0 = res + val.quadraticAttenuation;
1663                         ${FRAGMENT_OUTPUT}
1664                 }
1665         ""
1666 end
1667
1668 case uniform_struct_use_case_rip_sans_highp
1669         desc "Complex Light struct from use case tests, without highp usage"
1670         values {
1671                 uniform float val.constantAttenuation = 1.0;
1672                 uniform float val.quadraticAttenuation = 1.0;
1673             output float out0 = 2.0;
1674     }
1675         vertex ""
1676                  struct Light
1677                  {
1678                      mediump vec3       color;
1679                          mediump vec4   position;
1680                          mediump vec3   direction;
1681                          mediump float  constantAttenuation;
1682                          mediump float  linearAttenuation;
1683                          mediump float  quadraticAttenuation;
1684             };
1685                 ${VERTEX_DECLARATIONS}
1686                 uniform Light val;
1687                 varying mediump float res;
1688                 void main()
1689                 {
1690                         res = val.constantAttenuation;
1691                         ${VERTEX_OUTPUT}
1692                 }
1693         ""
1694         fragment ""
1695              precision mediump float;
1696                  struct Light
1697                  {
1698                      mediump vec3       color;
1699                          mediump vec4   position;
1700                          mediump vec3   direction;
1701                          mediump float  constantAttenuation;
1702                          mediump float  linearAttenuation;
1703                          mediump float  quadraticAttenuation;
1704             };
1705                 struct Struct {float a;};
1706                 uniform Light val;
1707                 ${FRAGMENT_DECLARATIONS}
1708                 varying mediump float res;
1709                 void main()
1710                 {
1711                         out0 = res + val.quadraticAttenuation;
1712                         ${FRAGMENT_OUTPUT}
1713                 }
1714         ""
1715 end