1 /* 2 * Copyright 2016 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "SkSLCompiler.h" 9 10 #include "Test.h" 11 12 #if SK_SUPPORT_GPU 13 14 // Note that the optimizer will aggressively kill dead code and substitute constants in place of 15 // variables, so we have to jump through a few hoops to ensure that the code in these tests has the 16 // necessary side-effects to remain live. In some cases we rely on the optimizer not (yet) being 17 // smart enough to optimize around certain constructs; as the optimizer gets smarter it will 18 // undoubtedly end up breaking some of these tests. That is a good thing, as long as the new code is 19 // equivalent! 20 21 static void test(skiatest::Reporter* r, const char* src, const SkSL::Program::Settings& settings, 22 const char* expected, SkSL::Program::Inputs* inputs, 23 SkSL::Program::Kind kind = SkSL::Program::kFragment_Kind) { 24 SkSL::Compiler compiler; 25 SkSL::String output; 26 std::unique_ptr<SkSL::Program> program = compiler.convertProgram(kind, SkSL::String(src), 27 settings); 28 if (!program) { 29 SkDebugf("Unexpected error compiling %s\n%s", src, compiler.errorText().c_str()); 30 } 31 REPORTER_ASSERT(r, program); 32 *inputs = program->fInputs; 33 REPORTER_ASSERT(r, compiler.toGLSL(*program, &output)); 34 if (program) { 35 SkSL::String skExpected(expected); 36 if (output != skExpected) { 37 SkDebugf("GLSL MISMATCH:\nsource:\n%s\n\nexpected:\n'%s'\n\nreceived:\n'%s'", src, 38 expected, output.c_str()); 39 } 40 REPORTER_ASSERT(r, output == skExpected); 41 } 42 } 43 44 static void test(skiatest::Reporter* r, const char* src, const GrShaderCaps& caps, 45 const char* expected, SkSL::Program::Kind kind = SkSL::Program::kFragment_Kind) { 46 SkSL::Program::Settings settings; 47 settings.fCaps = ∩︀ 48 SkSL::Program::Inputs inputs; 49 test(r, src, settings, expected, &inputs, kind); 50 } 51 52 DEF_TEST(SkSLHelloWorld, r) { 53 test(r, 54 "void main() { sk_FragColor = float4(0.75); }", 55 *SkSL::ShaderCapsFactory::Default(), 56 "#version 400\n" 57 "out vec4 sk_FragColor;\n" 58 "void main() {\n" 59 " sk_FragColor = vec4(0.75);\n" 60 "}\n"); 61 } 62 63 DEF_TEST(SkSLControl, r) { 64 test(r, 65 "void main() {" 66 "if (sqrt(2) > 5) { sk_FragColor = float4(0.75); } else { discard; }" 67 "int i = 0;" 68 "while (i < 10) { sk_FragColor *= 0.5; i++; }" 69 "do { sk_FragColor += 0.01; } while (sk_FragColor.x < 0.75);" 70 "for (int i = 0; i < 10; i++) {" 71 "if (i % 2 == 1) break; else continue;" 72 "}" 73 "return;" 74 "}", 75 *SkSL::ShaderCapsFactory::Default(), 76 "#version 400\n" 77 "out vec4 sk_FragColor;\n" 78 "void main() {\n" 79 " if (sqrt(2.0) > 5.0) {\n" 80 " sk_FragColor = vec4(0.75);\n" 81 " } else {\n" 82 " discard;\n" 83 " }\n" 84 " int i = 0;\n" 85 " while (i < 10) {\n" 86 " sk_FragColor *= 0.5;\n" 87 " i++;\n" 88 " }\n" 89 " do {\n" 90 " sk_FragColor += 0.01;\n" 91 " } while (sk_FragColor.x < 0.75);\n" 92 " for (int i = 0;i < 10; i++) {\n" 93 " if (i % 2 == 1) break; else continue;\n" 94 " }\n" 95 " return;\n" 96 "}\n"); 97 } 98 99 DEF_TEST(SkSLFunctions, r) { 100 test(r, 101 "float foo(float v[2]) { return v[0] * v[1]; }" 102 "void bar(inout float x) { float y[2], z; y[0] = x; y[1] = x * 2; z = foo(y); x = z; }" 103 "void main() { float x = 10; bar(x); sk_FragColor = float4(x); }", 104 *SkSL::ShaderCapsFactory::Default(), 105 "#version 400\n" 106 "out vec4 sk_FragColor;\n" 107 "float foo(float v[2]) {\n" 108 " return v[0] * v[1];\n" 109 "}\n" 110 "void bar(inout float x) {\n" 111 " float y[2], z;\n" 112 " y[0] = x;\n" 113 " y[1] = x * 2.0;\n" 114 " z = foo(y);\n" 115 " x = z;\n" 116 "}\n" 117 "void main() {\n" 118 " float x = 10.0;\n" 119 " bar(x);\n" 120 " sk_FragColor = vec4(x);\n" 121 "}\n"); 122 } 123 124 DEF_TEST(SkSLOperators, r) { 125 test(r, 126 "void main() {" 127 "float x = 1, y = 2;" 128 "int z = 3;" 129 "x = x - x + y * z * x * (y - z);" 130 "y = x / y / z;" 131 "z = (z / 2 % 3 << 4) >> 2 << 1;" 132 "bool b = (x > 4) == x < 2 || 2 >= sqrt(2) && y <= z;" 133 "x += 12;" 134 "x -= 12;" 135 "x *= y /= z = 10;" 136 "b ||= false;" 137 "b &&= true;" 138 "b ^^= false;" 139 "z |= 0;" 140 "z &= -1;" 141 "z ^= 0;" 142 "z >>= 2;" 143 "z <<= 4;" 144 "z %= 5;" 145 "x = (float2(sqrt(1)) , 6);" 146 "z = (float2(sqrt(1)) , 6);" 147 "}", 148 *SkSL::ShaderCapsFactory::Default(), 149 "#version 400\n" 150 "out vec4 sk_FragColor;\n" 151 "void main() {\n" 152 " float x = 1.0, y = 2.0;\n" 153 " int z = 3;\n" 154 " x = -6.0;\n" 155 " y = -1.0;\n" 156 " z = 8;\n" 157 " bool b = false == true || 2.0 >= sqrt(2.0) && true;\n" 158 " x += 12.0;\n" 159 " x -= 12.0;\n" 160 " x *= (y /= float(z = 10));\n" 161 " b ||= false;\n" 162 " b &&= true;\n" 163 " b ^^= false;\n" 164 " z |= 0;\n" 165 " z &= -1;\n" 166 " z ^= 0;\n" 167 " z >>= 2;\n" 168 " z <<= 4;\n" 169 " z %= 5;\n" 170 " x = float((vec2(sqrt(1.0)) , 6));\n" 171 " z = (vec2(sqrt(1.0)) , 6);\n" 172 "}\n"); 173 } 174 175 DEF_TEST(SkSLMatrices, r) { 176 test(r, 177 "void main() {" 178 "float2x4 x = float2x4(1);" 179 "float3x2 y = float3x2(1, 0, 0, 1, float2(2, 2));" 180 "float3x4 z = x * y;" 181 "float3 v1 = float3x3(1) * float3(2);" 182 "float3 v2 = float3(2) * float3x3(1);" 183 "sk_FragColor = float4(z[0].x, v1 + v2);" 184 "}", 185 *SkSL::ShaderCapsFactory::Default(), 186 "#version 400\n" 187 "out vec4 sk_FragColor;\n" 188 "void main() {\n" 189 " mat3x4 z = mat2x4(1.0) * mat3x2(1.0, 0.0, 0.0, 1.0, vec2(2.0, 2.0));\n" 190 " vec3 v1 = mat3(1.0) * vec3(2.0);\n" 191 " vec3 v2 = vec3(2.0) * mat3(1.0);\n" 192 " sk_FragColor = vec4(z[0].x, v1 + v2);\n" 193 "}\n"); 194 } 195 196 DEF_TEST(SkSLInterfaceBlock, r) { 197 test(r, 198 "uniform testBlock {" 199 "half x;" 200 "half y[2];" 201 "layout(binding=12) half3x2 z;" 202 "bool w;" 203 "};" 204 "void main() {" 205 " sk_FragColor = half4(x, y[0], y[1], 0);" 206 "}", 207 *SkSL::ShaderCapsFactory::Default(), 208 "#version 400\n" 209 "out vec4 sk_FragColor;\n" 210 "uniform testBlock {\n" 211 " float x;\n" 212 " float[2] y;\n" 213 " layout (binding = 12) mat3x2 z;\n" 214 " bool w;\n" 215 "};\n" 216 "void main() {\n" 217 " sk_FragColor = vec4(x, y[0], y[1], 0.0);\n" 218 "}\n"); 219 test(r, 220 "uniform testBlock {" 221 "float x;" 222 "} test;" 223 "void main() {" 224 " sk_FragColor = half4(test.x);" 225 "}", 226 *SkSL::ShaderCapsFactory::Default(), 227 "#version 400\n" 228 "out vec4 sk_FragColor;\n" 229 "uniform testBlock {\n" 230 " float x;\n" 231 "} test;\n" 232 "void main() {\n" 233 " sk_FragColor = vec4(test.x);\n" 234 "}\n"); 235 test(r, 236 "uniform testBlock {" 237 "float x;" 238 "} test[2];" 239 "void main() {" 240 " sk_FragColor = half4(test[1].x);" 241 "}", 242 *SkSL::ShaderCapsFactory::Default(), 243 "#version 400\n" 244 "out vec4 sk_FragColor;\n" 245 "uniform testBlock {\n" 246 " float x;\n" 247 "} test[2];\n" 248 "void main() {\n" 249 " sk_FragColor = vec4(test[1].x);\n" 250 "}\n"); 251 } 252 253 DEF_TEST(SkSLStructs, r) { 254 test(r, 255 "struct A {" 256 "int x;" 257 "int y;" 258 "} a1, a2;" 259 "A a3;" 260 "struct B {" 261 "float x;" 262 "float y[2];" 263 "layout(binding=1) A z;" 264 "};" 265 "B b1, b2, b3;" 266 "void main() {" 267 "}", 268 *SkSL::ShaderCapsFactory::Default(), 269 "#version 400\n" 270 "out vec4 sk_FragColor;\n" 271 "struct A {\n" 272 " int x;\n" 273 " int y;\n" 274 "} a1, a2;\n" 275 "A a3;\n" 276 "struct B {\n" 277 " float x;\n" 278 " float[2] y;\n" 279 " layout (binding = 1) A z;\n" 280 "} b1, b2, b3;\n" 281 "void main() {\n" 282 "}\n"); 283 } 284 285 DEF_TEST(SkSLVersion, r) { 286 test(r, 287 "in float test; void main() { sk_FragColor = float4(0.75); }", 288 *SkSL::ShaderCapsFactory::Version450Core(), 289 "#version 450 core\n" 290 "out vec4 sk_FragColor;\n" 291 "in float test;\n" 292 "void main() {\n" 293 " sk_FragColor = vec4(0.75);\n" 294 "}\n"); 295 test(r, 296 "in float test; void main() { sk_FragColor = float4(0.75); }", 297 *SkSL::ShaderCapsFactory::Version110(), 298 "#version 110\n" 299 "varying float test;\n" 300 "void main() {\n" 301 " gl_FragColor = vec4(0.75);\n" 302 "}\n"); 303 } 304 305 DEF_TEST(SkSLUsesPrecisionModifiers, r) { 306 test(r, 307 "void main() { half x = 0.75; float y = 1; x++; y++;" 308 "sk_FragColor.rg = half2(x, y); }", 309 *SkSL::ShaderCapsFactory::Default(), 310 "#version 400\n" 311 "out vec4 sk_FragColor;\n" 312 "void main() {\n" 313 " float x = 0.75;\n" 314 " float y = 1.0;\n" 315 " x++;\n" 316 " y++;\n" 317 " sk_FragColor.xy = vec2(x, y);\n" 318 "}\n"); 319 test(r, 320 "void main() { half x = 0.75; float y = 1; x++; y++;" 321 "sk_FragColor.rg = half2(x, y); }", 322 *SkSL::ShaderCapsFactory::UsesPrecisionModifiers(), 323 "#version 400\n" 324 "precision mediump float;\n" 325 "out mediump vec4 sk_FragColor;\n" 326 "void main() {\n" 327 " mediump float x = 0.75;\n" 328 " highp float y = 1.0;\n" 329 " x++;\n" 330 " y++;\n" 331 " sk_FragColor.xy = vec2(x, y);\n" 332 "}\n"); 333 } 334 335 DEF_TEST(SkSLMinAbs, r) { 336 test(r, 337 "void main() {" 338 "float x = -5;" 339 "sk_FragColor.r = min(abs(x), 6);" 340 "}", 341 *SkSL::ShaderCapsFactory::Default(), 342 "#version 400\n" 343 "out vec4 sk_FragColor;\n" 344 "void main() {\n" 345 " sk_FragColor.x = min(abs(-5.0), 6.0);\n" 346 "}\n"); 347 348 test(r, 349 "void main() {" 350 "float x = -5.0;" 351 "sk_FragColor.r = min(abs(x), 6.0);" 352 "}", 353 *SkSL::ShaderCapsFactory::CannotUseMinAndAbsTogether(), 354 "#version 400\n" 355 "out vec4 sk_FragColor;\n" 356 "void main() {\n" 357 " float minAbsHackVar0;\n" 358 " float minAbsHackVar1;\n" 359 " sk_FragColor.x = ((minAbsHackVar0 = abs(-5.0)) < (minAbsHackVar1 = 6.0) ? " 360 "minAbsHackVar0 : minAbsHackVar1);\n" 361 "}\n"); 362 } 363 364 DEF_TEST(SkSLFractNegative, r) { 365 static constexpr char input[] = 366 "void main() {" 367 "float x = -42.0;" 368 "sk_FragColor.r = fract(x);" 369 "}"; 370 static constexpr char output_default[] = 371 "#version 400\n" 372 "out vec4 sk_FragColor;\n" 373 "void main() {\n" 374 " sk_FragColor.x = fract(-42.0);\n" 375 "}\n"; 376 static constexpr char output_workaround[] = 377 "#version 400\n" 378 "out vec4 sk_FragColor;\n" 379 "void main() {\n" 380 " sk_FragColor.x = (0.5 - sign(-42.0) * (0.5 - fract(abs(-42.0))));\n" 381 "}\n"; 382 383 test(r, input, *SkSL::ShaderCapsFactory::Default(), output_default); 384 test(r, input, *SkSL::ShaderCapsFactory::CannotUseFractForNegativeValues(), output_workaround); 385 } 386 387 DEF_TEST(SkSLNegatedAtan, r) { 388 test(r, 389 "void main() { float2 x = float2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }", 390 *SkSL::ShaderCapsFactory::Default(), 391 "#version 400\n" 392 "out vec4 sk_FragColor;\n" 393 "void main() {\n" 394 " vec2 x = vec2(sqrt(2.0));\n" 395 " sk_FragColor.x = atan(x.x, -x.y);\n" 396 "}\n"); 397 test(r, 398 "void main() { float2 x = float2(sqrt(2)); sk_FragColor.r = atan(x.x, -x.y); }", 399 *SkSL::ShaderCapsFactory::MustForceNegatedAtanParamToFloat(), 400 "#version 400\n" 401 "out vec4 sk_FragColor;\n" 402 "void main() {\n" 403 " vec2 x = vec2(sqrt(2.0));\n" 404 " sk_FragColor.x = atan(x.x, -1.0 * x.y);\n" 405 "}\n"); 406 } 407 408 DEF_TEST(SkSLModifiersDeclaration, r) { 409 test(r, 410 "layout(blend_support_all_equations) out;" 411 "layout(blend_support_all_equations) out;" 412 "layout(blend_support_multiply) out;" 413 "layout(blend_support_screen) out;" 414 "layout(blend_support_overlay) out;" 415 "layout(blend_support_darken) out;" 416 "layout(blend_support_lighten) out;" 417 "layout(blend_support_colordodge) out;" 418 "layout(blend_support_colorburn) out;" 419 "layout(blend_support_hardlight) out;" 420 "layout(blend_support_softlight) out;" 421 "layout(blend_support_difference) out;" 422 "layout(blend_support_exclusion) out;" 423 "layout(blend_support_hsl_hue) out;" 424 "layout(blend_support_hsl_saturation) out;" 425 "layout(blend_support_hsl_color) out;" 426 "layout(blend_support_hsl_luminosity) out;" 427 "void main() { }", 428 *SkSL::ShaderCapsFactory::Default(), 429 "#version 400\n" 430 "out vec4 sk_FragColor;\n" 431 "layout (blend_support_all_equations) out ;\n" 432 "layout (blend_support_all_equations) out ;\n" 433 "layout (blend_support_multiply) out ;\n" 434 "layout (blend_support_screen) out ;\n" 435 "layout (blend_support_overlay) out ;\n" 436 "layout (blend_support_darken) out ;\n" 437 "layout (blend_support_lighten) out ;\n" 438 "layout (blend_support_colordodge) out ;\n" 439 "layout (blend_support_colorburn) out ;\n" 440 "layout (blend_support_hardlight) out ;\n" 441 "layout (blend_support_softlight) out ;\n" 442 "layout (blend_support_difference) out ;\n" 443 "layout (blend_support_exclusion) out ;\n" 444 "layout (blend_support_hsl_hue) out ;\n" 445 "layout (blend_support_hsl_saturation) out ;\n" 446 "layout (blend_support_hsl_color) out ;\n" 447 "layout (blend_support_hsl_luminosity) out ;\n" 448 "void main() {\n" 449 "}\n"); 450 } 451 452 DEF_TEST(SkSLHex, r) { 453 test(r, 454 "void main() {" 455 "int i1 = 0x0;" 456 "i1++;" 457 "int i2 = 0x1234abcd;" 458 "i2++;" 459 "int i3 = 0x7fffffff;" 460 "i3++;" 461 "int i4 = 0xffffffff;" 462 "i4++;" 463 "int i5 = -0xbeef;" 464 "i5++;" 465 "uint u1 = 0x0;" 466 "u1++;" 467 "uint u2 = 0x1234abcd;" 468 "u2++;" 469 "uint u3 = 0x7fffffff;" 470 "u3++;" 471 "uint u4 = 0xffffffff;" 472 "u4++;" 473 "ushort u5 = 0xffff;" 474 "u5++;" 475 "}", 476 *SkSL::ShaderCapsFactory::Default(), 477 "#version 400\n" 478 "out vec4 sk_FragColor;\n" 479 "void main() {\n" 480 " int i1 = 0;\n" 481 " i1++;\n" 482 " int i2 = 305441741;\n" 483 " i2++;\n" 484 " int i3 = 2147483647;\n" 485 " i3++;\n" 486 " int i4 = -1;\n" 487 " i4++;\n" 488 " int i5 = -48879;\n" 489 " i5++;\n" 490 " uint u1 = 0u;\n" 491 " u1++;\n" 492 " uint u2 = 305441741u;\n" 493 " u2++;\n" 494 " uint u3 = 2147483647u;\n" 495 " u3++;\n" 496 " uint u4 = 4294967295u;\n" 497 " u4++;\n" 498 " uint u5 = 65535u;\n" 499 " u5++;\n" 500 "}\n"); 501 } 502 503 DEF_TEST(SkSLVectorConstructors, r) { 504 test(r, 505 "float2 v1 = float2(1);" 506 "float2 v2 = float2(1, 2);" 507 "float2 v3 = float2(float2(1));" 508 "float3 v4 = float3(float2(1), 1.0);" 509 "int2 v5 = int2(1);" 510 "int2 v6 = int2(float2(1, 2));" 511 "float2 v7 = float2(int2(1, 2));", 512 *SkSL::ShaderCapsFactory::Default(), 513 "#version 400\n" 514 "out vec4 sk_FragColor;\n" 515 "vec2 v1 = vec2(1.0);\n" 516 "vec2 v2 = vec2(1.0, 2.0);\n" 517 "vec2 v3 = vec2(1.0);\n" 518 "vec3 v4 = vec3(vec2(1.0), 1.0);\n" 519 "ivec2 v5 = ivec2(1);\n" 520 "ivec2 v6 = ivec2(vec2(1.0, 2.0));\n" 521 "vec2 v7 = vec2(ivec2(1, 2));\n"); 522 } 523 524 DEF_TEST(SkSLArrayConstructors, r) { 525 test(r, 526 "float test1[] = float[](1, 2, 3, 4);" 527 "float2 test2[] = float2[](float2(1, 2), float2(3, 4));" 528 "float4x4 test3[] = float4x4[]();", 529 *SkSL::ShaderCapsFactory::Default(), 530 "#version 400\n" 531 "out vec4 sk_FragColor;\n" 532 "float test1[] = float[](1.0, 2.0, 3.0, 4.0);\n" 533 "vec2 test2[] = vec2[](vec2(1.0, 2.0), vec2(3.0, 4.0));\n" 534 "mat4 test3[] = mat4[]();\n"); 535 } 536 537 DEF_TEST(SkSLDerivatives, r) { 538 test(r, 539 "void main() { sk_FragColor.r = dFdx(1); }", 540 *SkSL::ShaderCapsFactory::Default(), 541 "#version 400\n" 542 "out vec4 sk_FragColor;\n" 543 "void main() {\n" 544 " sk_FragColor.x = dFdx(1.0);\n" 545 "}\n"); 546 test(r, 547 "void main() { sk_FragColor.r = 1; }", 548 *SkSL::ShaderCapsFactory::ShaderDerivativeExtensionString(), 549 "#version 400\n" 550 "precision mediump float;\n" 551 "out mediump vec4 sk_FragColor;\n" 552 "void main() {\n" 553 " sk_FragColor.x = 1.0;\n" 554 "}\n"); 555 test(r, 556 "void main() { sk_FragColor.r = dFdx(1); }", 557 *SkSL::ShaderCapsFactory::ShaderDerivativeExtensionString(), 558 "#version 400\n" 559 "#extension GL_OES_standard_derivatives : require\n" 560 "precision mediump float;\n" 561 "out mediump vec4 sk_FragColor;\n" 562 "void main() {\n" 563 " sk_FragColor.x = dFdx(1.0);\n" 564 "}\n"); 565 } 566 567 568 DEF_TEST(SkSLIntFolding, r) { 569 test(r, 570 "void main() {" 571 "sk_FragColor.r = 32 + 2;" 572 "sk_FragColor.r = 32 - 2;" 573 "sk_FragColor.r = 32 * 2;" 574 "sk_FragColor.r = 32 / 2;" 575 "sk_FragColor.r = 12 | 6;" 576 "sk_FragColor.r = 254 & 7;" 577 "sk_FragColor.r = 2 ^ 7;" 578 "sk_FragColor.r = 1 << 4;" 579 "sk_FragColor.r = 128 >> 2;" 580 "sk_FragColor.r = -1 == -1 ? 1 : -1;" 581 "sk_FragColor.r = -1 == -2 ? 2 : -2;" 582 "sk_FragColor.r = 0 != 1 ? 3 : -3;" 583 "sk_FragColor.r = 0 != 0 ? 4 : -4;" 584 "sk_FragColor.r = 6 > 5 ? 5 : -5;" 585 "sk_FragColor.r = 6 > 6 ? 6 : -6;" 586 "sk_FragColor.r = -1 < 0 ? 7 : -7;" 587 "sk_FragColor.r = 1 < 0 ? 8 : -8;" 588 "sk_FragColor.r = 6 >= 6 ? 9 : -9;" 589 "sk_FragColor.r = 6 >= 7 ? 10 : -10;" 590 "sk_FragColor.r = 6 <= 6 ? 11 : -11;" 591 "sk_FragColor.r = 6 <= 5 ? 12 : -12;" 592 "sk_FragColor.r = int(sqrt(1)) + 0;" 593 "sk_FragColor.r = 0 + int(sqrt(2));" 594 "sk_FragColor.r = int(sqrt(3)) - 0;" 595 "sk_FragColor.r = int(sqrt(4)) * 0;" 596 "sk_FragColor.r = int(sqrt(5)) * 1;" 597 "sk_FragColor.r = 1 * int(sqrt(6));" 598 "sk_FragColor.r = 0 * int(sqrt(7));" 599 "sk_FragColor.r = int(sqrt(8)) / 1;" 600 "sk_FragColor.r = 0 / int(sqrt(9));" 601 "int x = int(sqrt(2));" 602 "x += 1;" 603 "x += 0;" 604 "x -= 1;" 605 "x -= 0;" 606 "x *= 1;" 607 "x *= 2;" 608 "x /= 1;" 609 "x /= 2;" 610 "sk_FragColor.r = x;" 611 "}", 612 *SkSL::ShaderCapsFactory::Default(), 613 "#version 400\n" 614 "out vec4 sk_FragColor;\n" 615 "void main() {\n" 616 " sk_FragColor.x = 34.0;\n" 617 " sk_FragColor.x = 30.0;\n" 618 " sk_FragColor.x = 64.0;\n" 619 " sk_FragColor.x = 16.0;\n" 620 " sk_FragColor.x = 14.0;\n" 621 " sk_FragColor.x = 6.0;\n" 622 " sk_FragColor.x = 5.0;\n" 623 " sk_FragColor.x = 16.0;\n" 624 " sk_FragColor.x = 32.0;\n" 625 " sk_FragColor.x = 1.0;\n" 626 " sk_FragColor.x = -2.0;\n" 627 " sk_FragColor.x = 3.0;\n" 628 " sk_FragColor.x = -4.0;\n" 629 " sk_FragColor.x = 5.0;\n" 630 " sk_FragColor.x = -6.0;\n" 631 " sk_FragColor.x = 7.0;\n" 632 " sk_FragColor.x = -8.0;\n" 633 " sk_FragColor.x = 9.0;\n" 634 " sk_FragColor.x = -10.0;\n" 635 " sk_FragColor.x = 11.0;\n" 636 " sk_FragColor.x = -12.0;\n" 637 " sk_FragColor.x = float(int(sqrt(1.0)));\n" 638 " sk_FragColor.x = float(int(sqrt(2.0)));\n" 639 " sk_FragColor.x = float(int(sqrt(3.0)));\n" 640 " sk_FragColor.x = 0.0;\n" 641 " sk_FragColor.x = float(int(sqrt(5.0)));\n" 642 " sk_FragColor.x = float(int(sqrt(6.0)));\n" 643 " sk_FragColor.x = 0.0;\n" 644 " sk_FragColor.x = float(int(sqrt(8.0)));\n" 645 " sk_FragColor.x = 0.0;\n" 646 " int x = int(sqrt(2.0));\n" 647 " x += 1;\n" 648 " x -= 1;\n" 649 " x *= 2;\n" 650 " x /= 2;\n" 651 " sk_FragColor.x = float(x);\n" 652 "}\n"); 653 } 654 655 DEF_TEST(SkSLFloatFolding, r) { 656 test(r, 657 "void main() {" 658 "sk_FragColor.r = 32.0 + 2.0;" 659 "sk_FragColor.r = 32.0 - 2.0;" 660 "sk_FragColor.r = 32.0 * 2.0;" 661 "sk_FragColor.r = 32.0 / 2.0;" 662 "sk_FragColor.r = (12 > 2.0) ? (10 * 2 / 5 + 18 - 3) : 0;" 663 "sk_FragColor.r = 0.0 == 0.0 ? 1 : -1;" 664 "sk_FragColor.r = 0.0 == 1.0 ? 2 : -2;" 665 "sk_FragColor.r = 0.0 != 1.0 ? 3 : -3;" 666 "sk_FragColor.r = 0.0 != 0.0 ? 4 : -4;" 667 "sk_FragColor.r = 6.0 > 5.0 ? 5 : -5;" 668 "sk_FragColor.r = 6.0 > 6.0 ? 6 : -6;" 669 "sk_FragColor.r = 6.0 >= 6.0 ? 7 : -7;" 670 "sk_FragColor.r = 6.0 >= 7.0 ? 8 : -8;" 671 "sk_FragColor.r = 5.0 < 6.0 ? 9 : -9;" 672 "sk_FragColor.r = 6.0 < 6.0 ? 10 : -10;" 673 "sk_FragColor.r = 6.0 <= 6.0 ? 11 : -11;" 674 "sk_FragColor.r = 6.0 <= 5.0 ? 12 : -12;" 675 "sk_FragColor.r = sqrt(1) + 0;" 676 "sk_FragColor.r = 0 + sqrt(2);" 677 "sk_FragColor.r = sqrt(3) - 0;" 678 "sk_FragColor.r = sqrt(4) * 0;" 679 "sk_FragColor.r = sqrt(5) * 1;" 680 "sk_FragColor.r = 1 * sqrt(6);" 681 "sk_FragColor.r = 0 * sqrt(7);" 682 "sk_FragColor.r = sqrt(8) / 1;" 683 "sk_FragColor.r = 0 / sqrt(9);" 684 "sk_FragColor.r += 1;" 685 "sk_FragColor.r += 0;" 686 "sk_FragColor.r -= 1;" 687 "sk_FragColor.r -= 0;" 688 "sk_FragColor.r *= 1;" 689 "sk_FragColor.r *= 2;" 690 "sk_FragColor.r /= 1;" 691 "sk_FragColor.r /= 2;" 692 "}", 693 *SkSL::ShaderCapsFactory::Default(), 694 "#version 400\n" 695 "out vec4 sk_FragColor;\n" 696 "void main() {\n" 697 " sk_FragColor.x = 34.0;\n" 698 " sk_FragColor.x = 30.0;\n" 699 " sk_FragColor.x = 64.0;\n" 700 " sk_FragColor.x = 16.0;\n" 701 " sk_FragColor.x = 19.0;\n" 702 " sk_FragColor.x = 1.0;\n" 703 " sk_FragColor.x = -2.0;\n" 704 " sk_FragColor.x = 3.0;\n" 705 " sk_FragColor.x = -4.0;\n" 706 " sk_FragColor.x = 5.0;\n" 707 " sk_FragColor.x = -6.0;\n" 708 " sk_FragColor.x = 7.0;\n" 709 " sk_FragColor.x = -8.0;\n" 710 " sk_FragColor.x = 9.0;\n" 711 " sk_FragColor.x = -10.0;\n" 712 " sk_FragColor.x = 11.0;\n" 713 " sk_FragColor.x = -12.0;\n" 714 " sk_FragColor.x = sqrt(1.0);\n" 715 " sk_FragColor.x = sqrt(2.0);\n" 716 " sk_FragColor.x = sqrt(3.0);\n" 717 " sk_FragColor.x = 0.0;\n" 718 " sk_FragColor.x = sqrt(5.0);\n" 719 " sk_FragColor.x = sqrt(6.0);\n" 720 " sk_FragColor.x = 0.0;\n" 721 " sk_FragColor.x = sqrt(8.0);\n" 722 " sk_FragColor.x = 0.0;\n" 723 " sk_FragColor.x += 1.0;\n" 724 " sk_FragColor.x -= 1.0;\n" 725 " sk_FragColor.x *= 2.0;\n" 726 " sk_FragColor.x /= 2.0;\n" 727 "}\n"); 728 } 729 730 DEF_TEST(SkSLBoolFolding, r) { 731 test(r, 732 "void main() {" 733 "sk_FragColor.r = 1 == 1 || 2 == 8 ? 1 : -1;" 734 "sk_FragColor.r = 1 > 1 || 2 == 8 ? 2 : -2;" 735 "sk_FragColor.r = 1 == 1 && 2 <= 8 ? 3 : -3;" 736 "sk_FragColor.r = 1 == 2 && 2 == 8 ? 4 : -4;" 737 "sk_FragColor.r = 1 == 1 ^^ 1 != 1 ? 5 : -5;" 738 "sk_FragColor.r = 1 == 1 ^^ 1 == 1 ? 6 : -6;" 739 "}", 740 *SkSL::ShaderCapsFactory::Default(), 741 "#version 400\n" 742 "out vec4 sk_FragColor;\n" 743 "void main() {\n" 744 " sk_FragColor.x = 1.0;\n" 745 " sk_FragColor.x = -2.0;\n" 746 " sk_FragColor.x = 3.0;\n" 747 " sk_FragColor.x = -4.0;\n" 748 " sk_FragColor.x = 5.0;\n" 749 " sk_FragColor.x = -6.0;\n" 750 "}\n"); 751 } 752 753 DEF_TEST(SkSLVecFolding, r) { 754 test(r, 755 "void main() {" 756 "sk_FragColor.r = float4(0.5, 1, 1, 1).x;" 757 "sk_FragColor = float4(float2(1), float2(2, 3)) + float4(5, 6, 7, 8);" 758 "sk_FragColor = float4(8, float3(10)) - float4(1);" 759 "sk_FragColor = float4(2) * float4(1, 2, 3, 4);" 760 "sk_FragColor = float4(12) / float4(1, 2, 3, 4);" 761 "sk_FragColor.r = (float4(12) / float4(1, 2, 3, 4)).y;" 762 "sk_FragColor.x = float4(1) == float4(1) ? 1.0 : -1.0;" 763 "sk_FragColor.x = float4(1) == float4(2) ? 2.0 : -2.0;" 764 "sk_FragColor.x = float2(1) == float2(1, 1) ? 3.0 : -3.0;" 765 "sk_FragColor.x = float2(1, 1) == float2(1, 1) ? 4.0 : -4.0;" 766 "sk_FragColor.x = float2(1) == float2(1, 0) ? 5.0 : -5.0;" 767 "sk_FragColor.x = float4(1) == float4(float2(1), float2(1)) ? 6.0 : -6.0;" 768 "sk_FragColor.x = float4(float3(1), 1) == float4(float2(1), float2(1)) ? 7.0 : -7.0;" 769 "sk_FragColor.x = float4(float3(1), 1) == float4(float2(1), 1, 0) ? 8.0 : -8.0;" 770 "sk_FragColor.x = float2(1) != float2(1, 0) ? 9.0 : -9.0;" 771 "sk_FragColor.x = float4(1) != float4(float2(1), float2(1)) ? 10.0 : -10.0;" 772 "sk_FragColor = float4(sqrt(1)) * float4(1);" 773 "sk_FragColor = float4(1) * float4(sqrt(2));" 774 "sk_FragColor = float4(0) * float4(sqrt(3));" 775 "sk_FragColor = float4(sqrt(4)) * float4(0);" 776 "sk_FragColor = float4(0) / float4(sqrt(5));" 777 "sk_FragColor = float4(0) + float4(sqrt(6));" 778 "sk_FragColor = float4(sqrt(7)) + float4(0);" 779 "sk_FragColor = float4(sqrt(8)) - float4(0);" 780 "sk_FragColor = float4(0) + sqrt(9);" 781 "sk_FragColor = float4(0) * sqrt(10);" 782 "sk_FragColor = float4(0) / sqrt(11);" 783 "sk_FragColor = float4(1) * sqrt(12);" 784 "sk_FragColor = 0 + float4(sqrt(13));" 785 "sk_FragColor = 0 * float4(sqrt(14));" 786 "sk_FragColor = 0 / float4(sqrt(15));" 787 "sk_FragColor = 1 * float4(sqrt(16));" 788 "sk_FragColor = float4(sqrt(17)) + 0;" 789 "sk_FragColor = float4(sqrt(18)) * 0;" 790 "sk_FragColor = float4(sqrt(19)) * 1;" 791 "sk_FragColor = float4(sqrt(19.5)) - 0;" 792 "sk_FragColor = sqrt(20) * float4(1);" 793 "sk_FragColor = sqrt(21) + float4(0);" 794 "sk_FragColor = sqrt(22) - float4(0);" 795 "sk_FragColor = sqrt(23) / float4(1);" 796 "sk_FragColor = float4(sqrt(24)) / 1;" 797 "sk_FragColor += float4(1);" 798 "sk_FragColor += float4(0);" 799 "sk_FragColor -= float4(1);" 800 "sk_FragColor -= float4(0);" 801 "sk_FragColor *= float4(1);" 802 "sk_FragColor *= float4(2);" 803 "sk_FragColor /= float4(1);" 804 "sk_FragColor /= float4(2);" 805 "}", 806 *SkSL::ShaderCapsFactory::Default(), 807 "#version 400\n" 808 "out vec4 sk_FragColor;\n" 809 "void main() {\n" 810 " sk_FragColor.x = 0.5;\n" 811 " sk_FragColor = vec4(6.0, 7.0, 9.0, 11.0);\n" 812 " sk_FragColor = vec4(7.0, 9.0, 9.0, 9.0);\n" 813 " sk_FragColor = vec4(2.0, 4.0, 6.0, 8.0);\n" 814 " sk_FragColor = vec4(12.0, 6.0, 4.0, 3.0);\n" 815 " sk_FragColor.x = 6.0;\n" 816 " sk_FragColor.x = 1.0;\n" 817 " sk_FragColor.x = -2.0;\n" 818 " sk_FragColor.x = 3.0;\n" 819 " sk_FragColor.x = 4.0;\n" 820 " sk_FragColor.x = -5.0;\n" 821 " sk_FragColor.x = 6.0;\n" 822 " sk_FragColor.x = 7.0;\n" 823 " sk_FragColor.x = -8.0;\n" 824 " sk_FragColor.x = 9.0;\n" 825 " sk_FragColor.x = -10.0;\n" 826 " sk_FragColor = vec4(sqrt(1.0));\n" 827 " sk_FragColor = vec4(sqrt(2.0));\n" 828 " sk_FragColor = vec4(0.0);\n" 829 " sk_FragColor = vec4(0.0);\n" 830 " sk_FragColor = vec4(0.0);\n" 831 " sk_FragColor = vec4(sqrt(6.0));\n" 832 " sk_FragColor = vec4(sqrt(7.0));\n" 833 " sk_FragColor = vec4(sqrt(8.0));\n" 834 " sk_FragColor = vec4(sqrt(9.0));\n" 835 " sk_FragColor = vec4(0.0);\n" 836 " sk_FragColor = vec4(0.0);\n" 837 " sk_FragColor = vec4(sqrt(12.0));\n" 838 " sk_FragColor = vec4(sqrt(13.0));\n" 839 " sk_FragColor = vec4(0.0);\n" 840 " sk_FragColor = vec4(0.0);\n" 841 " sk_FragColor = vec4(sqrt(16.0));\n" 842 " sk_FragColor = vec4(sqrt(17.0));\n" 843 " sk_FragColor = vec4(0.0);\n" 844 " sk_FragColor = vec4(sqrt(19.0));\n" 845 " sk_FragColor = vec4(sqrt(19.5));\n" 846 " sk_FragColor = vec4(sqrt(20.0));\n" 847 " sk_FragColor = vec4(sqrt(21.0));\n" 848 " sk_FragColor = vec4(sqrt(22.0));\n" 849 " sk_FragColor = vec4(sqrt(23.0));\n" 850 " sk_FragColor = vec4(sqrt(24.0));\n" 851 " sk_FragColor += vec4(1.0);\n" 852 " sk_FragColor -= vec4(1.0);\n" 853 " sk_FragColor *= vec4(2.0);\n" 854 " sk_FragColor /= vec4(2.0);\n" 855 "}\n"); 856 } 857 858 DEF_TEST(SkSLMatFolding, r) { 859 test(r, 860 "void main() {" 861 "sk_FragColor.x = float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) == " 862 "float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 1 : -1;" 863 "sk_FragColor.x = float2x2(float2(1.0, 0.0), float2(1.0, 1.0)) == " 864 "float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 2 : -2;" 865 "sk_FragColor.x = float2x2(1) == float2x2(1) ? 3 : -3;" 866 "sk_FragColor.x = float2x2(1) == float2x2(0) ? 4 : -4;" 867 "sk_FragColor.x = float2x2(1) == float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 5 : -5;" 868 "sk_FragColor.x = float2x2(2) == float2x2(float2(1.0, 0.0), float2(0.0, 1.0)) ? 6 : -6;" 869 "sk_FragColor.x = float3x2(2) == float3x2(float2(2.0, 0.0), float2(0.0, 2.0), float2(0.0))" 870 "? 7 : -7;" 871 "sk_FragColor.x = float2x2(1) != float2x2(1) ? 8 : -8;" 872 "sk_FragColor.x = float2x2(1) != float2x2(0) ? 9 : -9;" 873 "sk_FragColor.x = float3x3(float3(1.0, 0.0, 0.0), float3(0.0, 1.0, 0.0), " 874 "float3(0.0, 0.0, 0.0)) == float3x3(float2x2(1.0)) ? 10 : -10;" 875 "sk_FragColor.x = float2x2(float3x3(1.0)) == float2x2(1.0) ? 11 : -11;" 876 "sk_FragColor.x = float2x2(float4(1.0, 0.0, 0.0, 1.0)) == float2x2(1.0) ? 12 : -12;" 877 "sk_FragColor.x = float2x2(1.0, 0.0, float2(0.0, 1.0)) == float2x2(1.0) ? 13 : -13;" 878 "sk_FragColor.x = float2x2(float2(1.0, 0.0), 0.0, 1.0) == float2x2(1.0) ? 14 : -14;" 879 "}", 880 *SkSL::ShaderCapsFactory::Default(), 881 "#version 400\n" 882 "out vec4 sk_FragColor;\n" 883 "void main() {\n" 884 " sk_FragColor.x = 1.0;\n" 885 " sk_FragColor.x = -2.0;\n" 886 " sk_FragColor.x = 3.0;\n" 887 " sk_FragColor.x = -4.0;\n" 888 " sk_FragColor.x = 5.0;\n" 889 " sk_FragColor.x = -6.0;\n" 890 " sk_FragColor.x = 7.0;\n" 891 " sk_FragColor.x = -8.0;\n" 892 " sk_FragColor.x = 9.0;\n" 893 " sk_FragColor.x = 10.0;\n" 894 " sk_FragColor.x = 11.0;\n" 895 " sk_FragColor.x = 12.0;\n" 896 " sk_FragColor.x = 13.0;\n" 897 " sk_FragColor.x = 14.0;\n" 898 "}\n"); 899 } 900 901 DEF_TEST(SkSLConstantIf, r) { 902 test(r, 903 "void main() {" 904 "int x;" 905 "if (true) x = 1;" 906 "if (2 > 1) x = 2; else x = 3;" 907 "if (1 > 2) x = 4; else x = 5;" 908 "if (false) x = 6;" 909 "sk_FragColor.r = x;" 910 "}", 911 *SkSL::ShaderCapsFactory::Default(), 912 "#version 400\n" 913 "out vec4 sk_FragColor;\n" 914 "void main() {\n" 915 " sk_FragColor.x = 5.0;\n" 916 "}\n"); 917 } 918 919 DEF_TEST(SkSLCaps, r) { 920 test(r, 921 "void main() {" 922 "int x = 0;" 923 "int y = 0;" 924 "int z = 0;" 925 "int w = 0;" 926 "if (sk_Caps.externalTextureSupport) x = 1;" 927 "if (sk_Caps.fbFetchSupport) y = 1;" 928 "if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.texelFetchSupport) z = 1;" 929 "if (sk_Caps.dropsTileOnZeroDivide && sk_Caps.canUseAnyFunctionInShader) w = 1;" 930 "sk_FragColor = half4(x, y, z, w);" 931 "}", 932 *SkSL::ShaderCapsFactory::VariousCaps(), 933 "#version 400\n" 934 "out vec4 sk_FragColor;\n" 935 "void main() {\n" 936 " sk_FragColor = vec4(1.0, 0.0, 1.0, 0.0);\n" 937 "}\n"); 938 } 939 940 DEF_TEST(SkSLTexture, r) { 941 test(r, 942 "uniform sampler1D one;" 943 "uniform sampler2D two;" 944 "void main() {" 945 "float4 a = texture(one, 0);" 946 "float4 b = texture(two, float2(0));" 947 "float4 c = texture(one, float2(0));" 948 "float4 d = texture(two, float3(0));" 949 "sk_FragColor = half4(a.x, b.x, c.x, d.x);" 950 "}", 951 *SkSL::ShaderCapsFactory::Default(), 952 "#version 400\n" 953 "out vec4 sk_FragColor;\n" 954 "uniform sampler1D one;\n" 955 "uniform sampler2D two;\n" 956 "void main() {\n" 957 " vec4 a = texture(one, 0.0);\n" 958 " vec4 b = texture(two, vec2(0.0));\n" 959 " vec4 c = textureProj(one, vec2(0.0));\n" 960 " vec4 d = textureProj(two, vec3(0.0));\n" 961 " sk_FragColor = vec4(a.x, b.x, c.x, d.x);\n" 962 "}\n"); 963 test(r, 964 "uniform sampler1D one;" 965 "uniform sampler2D two;" 966 "void main() {" 967 "float4 a = texture(one, 0);" 968 "float4 b = texture(two, float2(0));" 969 "float4 c = texture(one, float2(0));" 970 "float4 d = texture(two, float3(0));" 971 "sk_FragColor = half4(a.x, b.x, c.x, d.x);" 972 "}", 973 *SkSL::ShaderCapsFactory::Version110(), 974 "#version 110\n" 975 "uniform sampler1D one;\n" 976 "uniform sampler2D two;\n" 977 "void main() {\n" 978 " vec4 a = texture1D(one, 0.0);\n" 979 " vec4 b = texture2D(two, vec2(0.0));\n" 980 " vec4 c = texture1DProj(one, vec2(0.0));\n" 981 " vec4 d = texture2DProj(two, vec3(0.0));\n" 982 " gl_FragColor = vec4(a.x, b.x, c.x, d.x);\n" 983 "}\n"); 984 } 985 986 DEF_TEST(SkSLSharpen, r) { 987 SkSL::Program::Settings settings; 988 settings.fSharpenTextures = true; 989 sk_sp<GrShaderCaps> caps = SkSL::ShaderCapsFactory::Default(); 990 settings.fCaps = caps.get(); 991 SkSL::Program::Inputs inputs; 992 test(r, 993 "uniform sampler1D one;" 994 "uniform sampler2D two;" 995 "void main() {" 996 "float4 a = texture(one, 0);" 997 "float4 b = texture(two, float2(0));" 998 "float4 c = texture(one, float2(0));" 999 "float4 d = texture(two, float3(0));" 1000 "sk_FragColor = half4(a.x, b.x, c.x, d.x);" 1001 "}", 1002 settings, 1003 "#version 400\n" 1004 "out vec4 sk_FragColor;\n" 1005 "uniform sampler1D one;\n" 1006 "uniform sampler2D two;\n" 1007 "void main() {\n" 1008 " vec4 a = texture(one, 0.0, -0.5);\n" 1009 " vec4 b = texture(two, vec2(0.0), -0.5);\n" 1010 " vec4 c = textureProj(one, vec2(0.0), -0.5);\n" 1011 " vec4 d = textureProj(two, vec3(0.0), -0.5);\n" 1012 " sk_FragColor = vec4(a.x, b.x, c.x, d.x);\n" 1013 "}\n", 1014 &inputs); 1015 1016 caps = SkSL::ShaderCapsFactory::Version110(); 1017 settings.fCaps = caps.get(); 1018 test(r, 1019 "uniform sampler1D one;" 1020 "uniform sampler2D two;" 1021 "void main() {" 1022 "float4 a = texture(one, 0);" 1023 "float4 b = texture(two, float2(0));" 1024 "float4 c = texture(one, float2(0));" 1025 "float4 d = texture(two, float3(0));" 1026 "sk_FragColor = half4(a.x, b.x, c.x, d.x);" 1027 "}", 1028 settings, 1029 "#version 110\n" 1030 "uniform sampler1D one;\n" 1031 "uniform sampler2D two;\n" 1032 "void main() {\n" 1033 " vec4 a = texture1D(one, 0.0, -0.5);\n" 1034 " vec4 b = texture2D(two, vec2(0.0), -0.5);\n" 1035 " vec4 c = texture1DProj(one, vec2(0.0), -0.5);\n" 1036 " vec4 d = texture2DProj(two, vec3(0.0), -0.5);\n" 1037 " gl_FragColor = vec4(a.x, b.x, c.x, d.x);\n" 1038 "}\n", 1039 &inputs); 1040 } 1041 1042 DEF_TEST(SkSLOffset, r) { 1043 test(r, 1044 "struct Test {" 1045 "layout(offset = 0) int x;" 1046 "layout(offset = 4) int y;" 1047 "int z;" 1048 "} test;", 1049 *SkSL::ShaderCapsFactory::Default(), 1050 "#version 400\n" 1051 "out vec4 sk_FragColor;\n" 1052 "struct Test {\n" 1053 " layout (offset = 0) int x;\n" 1054 " layout (offset = 4) int y;\n" 1055 " int z;\n" 1056 "} test;\n"); 1057 } 1058 1059 DEF_TEST(SkSLFragCoord, r) { 1060 SkSL::Program::Settings settings; 1061 settings.fFlipY = true; 1062 sk_sp<GrShaderCaps> caps = SkSL::ShaderCapsFactory::FragCoordsOld(); 1063 settings.fCaps = caps.get(); 1064 SkSL::Program::Inputs inputs; 1065 test(r, 1066 "void main() { sk_FragColor.xy = sk_FragCoord.xy; }", 1067 settings, 1068 "#version 110\n" 1069 "#extension GL_ARB_fragment_coord_conventions : require\n" 1070 "layout(origin_upper_left) in vec4 gl_FragCoord;\n" 1071 "void main() {\n" 1072 " gl_FragColor.xy = gl_FragCoord.xy;\n" 1073 "}\n", 1074 &inputs); 1075 REPORTER_ASSERT(r, !inputs.fRTHeight); 1076 1077 caps = SkSL::ShaderCapsFactory::FragCoordsNew(); 1078 settings.fCaps = caps.get(); 1079 test(r, 1080 "void main() { sk_FragColor.xy = sk_FragCoord.xy; }", 1081 settings, 1082 "#version 400\n" 1083 "layout(origin_upper_left) in vec4 gl_FragCoord;\n" 1084 "out vec4 sk_FragColor;\n" 1085 "void main() {\n" 1086 " sk_FragColor.xy = gl_FragCoord.xy;\n" 1087 "}\n", 1088 &inputs); 1089 REPORTER_ASSERT(r, !inputs.fRTHeight); 1090 1091 caps = SkSL::ShaderCapsFactory::Default(); 1092 settings.fCaps = caps.get(); 1093 test(r, 1094 "void main() { sk_FragColor.xy = sk_FragCoord.xy; }", 1095 settings, 1096 "#version 400\n" 1097 "uniform float u_skRTHeight;\n" 1098 "out vec4 sk_FragColor;\n" 1099 "void main() {\n" 1100 " vec2 _sktmpCoord = gl_FragCoord.xy;\n" 1101 " vec4 sk_FragCoord = vec4(_sktmpCoord.x, u_skRTHeight - _sktmpCoord.y, 1.0, 1.0);\n" 1102 " sk_FragColor.xy = sk_FragCoord.xy;\n" 1103 "}\n", 1104 &inputs); 1105 REPORTER_ASSERT(r, inputs.fRTHeight); 1106 1107 settings.fFlipY = false; 1108 test(r, 1109 "void main() { sk_FragColor.xy = sk_FragCoord.xy; }", 1110 settings, 1111 "#version 400\n" 1112 "out vec4 sk_FragColor;\n" 1113 "void main() {\n" 1114 " sk_FragColor.xy = gl_FragCoord.xy;\n" 1115 "}\n", 1116 &inputs); 1117 REPORTER_ASSERT(r, !inputs.fRTHeight); 1118 1119 test(r, 1120 "in float4 pos; void main() { sk_Position = pos; }", 1121 *SkSL::ShaderCapsFactory::CannotUseFragCoord(), 1122 "#version 400\n" 1123 "out vec4 sk_FragCoord_Workaround;\n" 1124 "in vec4 pos;\n" 1125 "void main() {\n" 1126 " sk_FragCoord_Workaround = (gl_Position = pos);\n" 1127 "}\n", 1128 SkSL::Program::kVertex_Kind); 1129 1130 test(r, 1131 "in uniform float4 sk_RTAdjust; in float4 pos; void main() { sk_Position = pos; }", 1132 *SkSL::ShaderCapsFactory::CannotUseFragCoord(), 1133 "#version 400\n" 1134 "out vec4 sk_FragCoord_Workaround;\n" 1135 "in uniform vec4 sk_RTAdjust;\n" 1136 "in vec4 pos;\n" 1137 "void main() {\n" 1138 " sk_FragCoord_Workaround = (gl_Position = pos);\n" 1139 " gl_Position = vec4(gl_Position.x * sk_RTAdjust.x + gl_Position.w * sk_RTAdjust.y, " 1140 "gl_Position.y * sk_RTAdjust.z + gl_Position.w * sk_RTAdjust.w, 0.0, " 1141 "gl_Position.w);\n" 1142 "}\n", 1143 SkSL::Program::kVertex_Kind); 1144 1145 test(r, 1146 "void main() { sk_FragColor.xy = sk_FragCoord.xy; }", 1147 *SkSL::ShaderCapsFactory::CannotUseFragCoord(), 1148 "#version 400\n" 1149 "in vec4 sk_FragCoord_Workaround;\n" 1150 "out vec4 sk_FragColor;\n" 1151 "void main() {\n" 1152 " float sk_FragCoord_InvW = 1. / sk_FragCoord_Workaround.w;\n" 1153 " vec4 sk_FragCoord_Resolved = vec4(sk_FragCoord_Workaround.xyz * " 1154 "sk_FragCoord_InvW, sk_FragCoord_InvW);\n" 1155 " sk_FragCoord_Resolved.xy = floor(sk_FragCoord_Resolved.xy) + vec2(.5);\n" 1156 " sk_FragColor.xy = sk_FragCoord_Resolved.xy;\n" 1157 "}\n"); 1158 } 1159 1160 DEF_TEST(SkSLVertexID, r) { 1161 test(r, 1162 "out int id; void main() { id = sk_VertexID; }", 1163 *SkSL::ShaderCapsFactory::Default(), 1164 "#version 400\n" 1165 "out int id;\n" 1166 "void main() {\n" 1167 " id = gl_VertexID;\n" 1168 "}\n", 1169 SkSL::Program::kVertex_Kind); 1170 } 1171 1172 DEF_TEST(SkSLInstanceID, r) { 1173 test(r, 1174 "out int id; void main() { id = sk_InstanceID; }", 1175 *SkSL::ShaderCapsFactory::Default(), 1176 "#version 400\n" 1177 "out int id;\n" 1178 "void main() {\n" 1179 " id = gl_InstanceID;\n" 1180 "}\n", 1181 SkSL::Program::kVertex_Kind); 1182 } 1183 1184 DEF_TEST(SkSLClipDistance, r) { 1185 test(r, 1186 "void main() { sk_ClipDistance[0] = 0; }", 1187 *SkSL::ShaderCapsFactory::Default(), 1188 "#version 400\n" 1189 "void main() {\n" 1190 " gl_ClipDistance[0] = 0.0;\n" 1191 "}\n", 1192 SkSL::Program::kVertex_Kind); 1193 test(r, 1194 "void main() { sk_FragColor = half4(sk_ClipDistance[0]); }", 1195 *SkSL::ShaderCapsFactory::Default(), 1196 "#version 400\n" 1197 "out vec4 sk_FragColor;\n" 1198 "void main() {\n" 1199 " sk_FragColor = vec4(gl_ClipDistance[0]);\n" 1200 "}\n"); 1201 } 1202 1203 DEF_TEST(SkSLArrayTypes, r) { 1204 test(r, 1205 "void main() { float2 x[2] = float2[2](float2(1), float2(2));" 1206 "float2[2] y = float2[2](float2(3), float2(4));" 1207 "sk_FragColor = float4(x[0], y[1]); }", 1208 *SkSL::ShaderCapsFactory::Default(), 1209 "#version 400\n" 1210 "out vec4 sk_FragColor;\n" 1211 "void main() {\n" 1212 " sk_FragColor = vec4(vec2[2](vec2(1.0), vec2(2.0))[0], " 1213 "vec2[2](vec2(3.0), vec2(4.0))[1]);\n" 1214 "}\n"); 1215 } 1216 1217 DEF_TEST(SkSLArrayIndexTypes, r) { 1218 test(r, 1219 "void main() { float array[4] = float[4](1, 2, 3, 4);" 1220 "short x = 0; ushort y = 1; int z = 2; uint w = 3;" 1221 "sk_FragColor = float4(array[x], array[y], array[z], array[w]); }", 1222 *SkSL::ShaderCapsFactory::Default(), 1223 "#version 400\n" 1224 "out vec4 sk_FragColor;\n" 1225 "void main() {\n" 1226 " sk_FragColor = vec4(float[4](1.0, 2.0, 3.0, 4.0)[0], " 1227 "float[4](1.0, 2.0, 3.0, 4.0)[1], " 1228 "float[4](1.0, 2.0, 3.0, 4.0)[2], " 1229 "float[4](1.0, 2.0, 3.0, 4.0)[3]);\n" 1230 "}\n"); 1231 } 1232 1233 DEF_TEST(SkSLGeometry, r) { 1234 test(r, 1235 "layout(points) in;" 1236 "layout(invocations = 2) in;" 1237 "layout(line_strip, max_vertices = 2) out;" 1238 "void main() {" 1239 "sk_Position = sk_in[0].sk_Position + float4(-0.5, 0, 0, sk_InvocationID);" 1240 "EmitVertex();" 1241 "sk_Position = sk_in[0].sk_Position + float4(0.5, 0, 0, sk_InvocationID);" 1242 "EmitVertex();" 1243 "EndPrimitive();" 1244 "}", 1245 *SkSL::ShaderCapsFactory::GeometryShaderSupport(), 1246 "#version 400\n" 1247 "layout (points) in ;\n" 1248 "layout (invocations = 2) in ;\n" 1249 "layout (line_strip, max_vertices = 2) out ;\n" 1250 "void main() {\n" 1251 " gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, float(gl_InvocationID));\n" 1252 " EmitVertex();\n" 1253 " gl_Position = gl_in[0].gl_Position + vec4(0.5, 0.0, 0.0, float(gl_InvocationID));\n" 1254 " EmitVertex();\n" 1255 " EndPrimitive();\n" 1256 "}\n", 1257 SkSL::Program::kGeometry_Kind); 1258 } 1259 1260 DEF_TEST(SkSLSwitch, r) { 1261 // basic "does a switch even work" test 1262 test(r, 1263 "void main() {" 1264 " float x;" 1265 " switch (int(sqrt(1))) {" 1266 " case 0:" 1267 " x = 0.0;" 1268 " break;" 1269 " case 1:" 1270 " x = 1.0;" 1271 " break;" 1272 " default:" 1273 " x = 2.0;" 1274 " }" 1275 " sk_FragColor = float4(x);" 1276 "}", 1277 *SkSL::ShaderCapsFactory::Default(), 1278 "#version 400\n" 1279 "out vec4 sk_FragColor;\n" 1280 "void main() {\n" 1281 " float x;\n" 1282 " switch (int(sqrt(1.0))) {\n" 1283 " case 0:\n" 1284 " x = 0.0;\n" 1285 " break;\n" 1286 " case 1:\n" 1287 " x = 1.0;\n" 1288 " break;\n" 1289 " default:\n" 1290 " x = 2.0;\n" 1291 " }\n" 1292 " sk_FragColor = vec4(x);\n" 1293 "}\n"); 1294 // dead code inside of switch 1295 test(r, 1296 "void main() {" 1297 " float x;" 1298 " switch (int(sqrt(2))) {" 1299 " case 0:" 1300 " x = 0.0;" 1301 " case 1:" 1302 " x = 1.0;" 1303 " default:" 1304 " x = 2.0;" 1305 " }" 1306 " sk_FragColor = half4(x);" 1307 "}", 1308 *SkSL::ShaderCapsFactory::Default(), 1309 "#version 400\n" 1310 "out vec4 sk_FragColor;\n" 1311 "void main() {\n" 1312 " switch (int(sqrt(2.0))) {\n" 1313 " case 0:\n" 1314 " ;\n" 1315 " case 1:\n" 1316 " ;\n" 1317 " default:\n" 1318 " ;\n" 1319 " }\n" 1320 " sk_FragColor = vec4(2.0);\n" 1321 "}\n"); 1322 // non-static test w/ fallthrough 1323 test(r, 1324 "void main() {" 1325 " float x = 0.0;" 1326 " switch (int(sqrt(3))) {" 1327 " case 0:" 1328 " x = 0.0;" 1329 " case 1:" 1330 " x = 1.0;" 1331 " }" 1332 " sk_FragColor = half4(x);" 1333 "}", 1334 *SkSL::ShaderCapsFactory::Default(), 1335 "#version 400\n" 1336 "out vec4 sk_FragColor;\n" 1337 "void main() {\n" 1338 " float x = 0.0;\n" 1339 " switch (int(sqrt(3.0))) {\n" 1340 " case 0:\n" 1341 " x = 0.0;\n" 1342 " case 1:\n" 1343 " x = 1.0;\n" 1344 " }\n" 1345 " sk_FragColor = vec4(x);\n" 1346 "}\n"); 1347 // static test w/ fallthrough 1348 test(r, 1349 "void main() {" 1350 " float x = 0.0;" 1351 " switch (0) {" 1352 " case 0:" 1353 " x = 0.0;" 1354 " case 1:" 1355 " x = 1.0;" 1356 " }" 1357 " sk_FragColor = half4(x);" 1358 "}", 1359 *SkSL::ShaderCapsFactory::Default(), 1360 "#version 400\n" 1361 "out vec4 sk_FragColor;\n" 1362 "void main() {\n" 1363 " sk_FragColor = vec4(1.0);\n" 1364 "}\n"); 1365 // static test w/ fallthrough, different entry point 1366 test(r, 1367 "void main() {" 1368 " float x = 0.0;" 1369 " switch (1) {" 1370 " case 0:" 1371 " x = 0.0;" 1372 " case 1:" 1373 " x = 1.0;" 1374 " }" 1375 " sk_FragColor = half4(x);" 1376 "}", 1377 *SkSL::ShaderCapsFactory::Default(), 1378 "#version 400\n" 1379 "out vec4 sk_FragColor;\n" 1380 "void main() {\n" 1381 " sk_FragColor = vec4(1.0);\n" 1382 "}\n"); 1383 // static test w/ break 1384 test(r, 1385 "void main() {" 1386 " float x = 0.0;" 1387 " switch (0) {" 1388 " case 0:" 1389 " x = 0.0;" 1390 " break;" 1391 " case 1:" 1392 " x = 1.0;" 1393 " }" 1394 " sk_FragColor = half4(x);" 1395 "}", 1396 *SkSL::ShaderCapsFactory::Default(), 1397 "#version 400\n" 1398 "out vec4 sk_FragColor;\n" 1399 "void main() {\n" 1400 " sk_FragColor = vec4(0.0);\n" 1401 "}\n"); 1402 // static test w/ static conditional break 1403 test(r, 1404 "void main() {" 1405 " float x = 0.0;" 1406 " switch (0) {" 1407 " case 0:" 1408 " x = 0.0;" 1409 " if (x < 1) break;" 1410 " case 1:" 1411 " x = 1.0;" 1412 " }" 1413 " sk_FragColor = half4(x);" 1414 "}", 1415 *SkSL::ShaderCapsFactory::Default(), 1416 "#version 400\n" 1417 "out vec4 sk_FragColor;\n" 1418 "void main() {\n" 1419 " sk_FragColor = vec4(0.0);\n" 1420 "}\n"); 1421 // static test w/ non-static conditional break 1422 test(r, 1423 "void main() {" 1424 " float x = 0.0;" 1425 " switch (0) {" 1426 " case 0:" 1427 " x = 0.0;" 1428 " if (x < sqrt(1)) break;" 1429 " case 1:" 1430 " x = 1.0;" 1431 " }" 1432 " sk_FragColor = half4(x);" 1433 "}", 1434 *SkSL::ShaderCapsFactory::Default(), 1435 "#version 400\n" 1436 "out vec4 sk_FragColor;\n" 1437 "void main() {\n" 1438 " float x = 0.0;\n" 1439 " switch (0) {\n" 1440 " case 0:\n" 1441 " x = 0.0;\n" 1442 " if (0.0 < sqrt(1.0)) break;\n" 1443 " case 1:\n" 1444 " x = 1.0;\n" 1445 " }\n" 1446 " sk_FragColor = vec4(x);\n" 1447 "}\n"); 1448 } 1449 1450 DEF_TEST(SkSLRectangleTexture, r) { 1451 test(r, 1452 "uniform sampler2D test;" 1453 "void main() {" 1454 " sk_FragColor = texture(test, float2(0.5));" 1455 "}", 1456 *SkSL::ShaderCapsFactory::Default(), 1457 "#version 400\n" 1458 "out vec4 sk_FragColor;\n" 1459 "uniform sampler2D test;\n" 1460 "void main() {\n" 1461 " sk_FragColor = texture(test, vec2(0.5));\n" 1462 "}\n"); 1463 test(r, 1464 "uniform sampler2DRect test;" 1465 "void main() {" 1466 " sk_FragColor = texture(test, float2(0.5));" 1467 "}", 1468 *SkSL::ShaderCapsFactory::Default(), 1469 "#version 400\n" 1470 "out vec4 sk_FragColor;\n" 1471 "uniform sampler2DRect test;\n" 1472 "void main() {\n" 1473 " sk_FragColor = texture(test, textureSize(test) * vec2(0.5));\n" 1474 "}\n"); 1475 test(r, 1476 "uniform sampler2DRect test;" 1477 "void main() {" 1478 " sk_FragColor = texture(test, float3(0.5));" 1479 "}", 1480 *SkSL::ShaderCapsFactory::Default(), 1481 "#version 400\n" 1482 "out vec4 sk_FragColor;\n" 1483 "uniform sampler2DRect test;\n" 1484 "void main() {\n" 1485 " sk_FragColor = texture(test, vec3(textureSize(test), 1.0) * vec3(0.5));\n" 1486 "}\n"); 1487 } 1488 1489 DEF_TEST(SkSLUnusedVars, r) { 1490 test(r, 1491 "void main() {" 1492 "float a = 1, b = 2, c = 3;" 1493 "float d = c;" 1494 "float e = d;" 1495 "b++;" 1496 "d++;" 1497 "sk_FragColor = float4(b, b, d, d);" 1498 "}", 1499 *SkSL::ShaderCapsFactory::Default(), 1500 "#version 400\n" 1501 "out vec4 sk_FragColor;\n" 1502 "void main() {\n" 1503 " float b = 2.0;\n" 1504 " float d = 3.0;\n" 1505 " b++;\n" 1506 " d++;\n" 1507 " sk_FragColor = vec4(b, b, d, d);\n" 1508 "}\n"); 1509 } 1510 1511 DEF_TEST(SkSLMultipleAssignments, r) { 1512 test(r, 1513 "void main() {" 1514 "float x;" 1515 "float y;" 1516 "int z;" 1517 "x = y = z = 1;" 1518 "sk_FragColor = float4(z);" 1519 "}", 1520 *SkSL::ShaderCapsFactory::Default(), 1521 "#version 400\n" 1522 "out vec4 sk_FragColor;\n" 1523 "void main() {\n" 1524 " sk_FragColor = vec4(1.0);\n" 1525 "}\n"); 1526 } 1527 1528 DEF_TEST(SkSLComplexDelete, r) { 1529 test(r, 1530 "uniform float4x4 colorXform;" 1531 "uniform sampler2D sampler;" 1532 "void main() {" 1533 "float4 tmpColor;" 1534 "sk_FragColor = float4(1.0) * (tmpColor = texture(sampler, float2(1)) , " 1535 "colorXform != float4x4(1.0) ? float4(clamp((float4x4(colorXform) * " 1536 "float4(tmpColor.xyz, 1.0)).xyz, " 1537 "0.0, tmpColor.w), tmpColor.w) : tmpColor);" 1538 "}", 1539 *SkSL::ShaderCapsFactory::Default(), 1540 "#version 400\n" 1541 "out vec4 sk_FragColor;\n" 1542 "uniform mat4 colorXform;\n" 1543 "uniform sampler2D sampler;\n" 1544 "void main() {\n" 1545 " vec4 tmpColor;\n" 1546 " sk_FragColor = (tmpColor = texture(sampler, vec2(1.0)) , colorXform != mat4(1.0) ? " 1547 "vec4(clamp((colorXform * vec4(tmpColor.xyz, 1.0)).xyz, 0.0, tmpColor.w), tmpColor.w) : " 1548 "tmpColor);\n" 1549 "}\n"); 1550 } 1551 1552 DEF_TEST(SkSLDependentInitializers, r) { 1553 test(r, 1554 "void main() {" 1555 "float x = 0.5, y = x * 2;" 1556 "sk_FragColor = float4(y);" 1557 "}", 1558 *SkSL::ShaderCapsFactory::Default(), 1559 "#version 400\n" 1560 "out vec4 sk_FragColor;\n" 1561 "void main() {\n" 1562 " sk_FragColor = vec4(1.0);\n" 1563 "}\n"); 1564 } 1565 1566 DEF_TEST(SkSLDeadLoopVar, r) { 1567 test(r, 1568 "void main() {" 1569 "for (int x = 0; x < 4; ) {" 1570 "break;" 1571 "}" 1572 "}", 1573 *SkSL::ShaderCapsFactory::Default(), 1574 "#version 400\n" 1575 "out vec4 sk_FragColor;\n" 1576 "void main() {\n" 1577 " for (; true; ) {\n" 1578 " break;\n" 1579 " }\n" 1580 "}\n" 1581 ); 1582 } 1583 1584 DEF_TEST(SkSLGeometryShaders, r) { 1585 test(r, 1586 "layout(points) in;" 1587 "layout(invocations = 2) in;" 1588 "layout(line_strip, max_vertices = 2) out;" 1589 "void test() {" 1590 "sk_Position = sk_in[0].sk_Position + float4(0.5, 0, 0, sk_InvocationID);" 1591 "EmitVertex();" 1592 "}" 1593 "void main() {" 1594 "sk_Position = sk_in[0].sk_Position + float4(-0.5, 0, 0, sk_InvocationID);" 1595 "EmitVertex();" 1596 "}", 1597 *SkSL::ShaderCapsFactory::NoGSInvocationsSupport(), 1598 "#version 400\n" 1599 "int sk_InvocationID;\n" 1600 "layout (points) in ;\n" 1601 "layout (line_strip, max_vertices = 4) out ;\n" 1602 "void test() {\n" 1603 " gl_Position = gl_in[0].gl_Position + vec4(0.5, 0.0, 0.0, float(sk_InvocationID));\n" 1604 " EmitVertex();\n" 1605 "}\n" 1606 "void _invoke() {\n" 1607 " gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, float(sk_InvocationID));\n" 1608 " EmitVertex();\n" 1609 "}\n" 1610 "void main() {\n" 1611 " for (sk_InvocationID = 0;sk_InvocationID < 2; sk_InvocationID++) {\n" 1612 " _invoke();\n" 1613 " EndPrimitive();\n" 1614 " }\n" 1615 "}\n", 1616 SkSL::Program::kGeometry_Kind); 1617 test(r, 1618 "layout(points, invocations = 2) in;" 1619 "layout(invocations = 3) in;" 1620 "layout(line_strip, max_vertices = 2) out;" 1621 "void main() {" 1622 "sk_Position = sk_in[0].sk_Position + float4(-0.5, 0, 0, sk_InvocationID);" 1623 "EmitVertex();" 1624 "EndPrimitive();" 1625 "}", 1626 *SkSL::ShaderCapsFactory::GSInvocationsExtensionString(), 1627 "#version 400\n" 1628 "#extension GL_ARB_gpu_shader5 : require\n" 1629 "layout (points, invocations = 2) in ;\n" 1630 "layout (invocations = 3) in ;\n" 1631 "layout (line_strip, max_vertices = 2) out ;\n" 1632 "void main() {\n" 1633 " gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, float(gl_InvocationID));\n" 1634 " EmitVertex();\n" 1635 " EndPrimitive();\n" 1636 "}\n", 1637 SkSL::Program::kGeometry_Kind); 1638 test(r, 1639 "layout(points, invocations = 2) in;" 1640 "layout(invocations = 3) in;" 1641 "layout(line_strip, max_vertices = 2) out;" 1642 "void main() {" 1643 "sk_Position = sk_in[0].sk_Position + float4(-0.5, 0, 0, sk_InvocationID);" 1644 "EmitVertex();" 1645 "EndPrimitive();" 1646 "}", 1647 *SkSL::ShaderCapsFactory::GeometryShaderExtensionString(), 1648 "#version 310es\n" 1649 "#extension GL_EXT_geometry_shader : require\n" 1650 "layout (points, invocations = 2) in ;\n" 1651 "layout (invocations = 3) in ;\n" 1652 "layout (line_strip, max_vertices = 2) out ;\n" 1653 "void main() {\n" 1654 " gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, float(gl_InvocationID));\n" 1655 " EmitVertex();\n" 1656 " EndPrimitive();\n" 1657 "}\n", 1658 SkSL::Program::kGeometry_Kind); 1659 } 1660 1661 DEF_TEST(SkSLTypePrecision, r) { 1662 test(r, 1663 "float f = 1;" 1664 "half h = 2;" 1665 "double d = 3;" 1666 "float2 f2 = float2(1, 2);" 1667 "half3 h3 = half3(1, 2, 3);" 1668 "double4 d4 = double4(1, 2, 3, 4);" 1669 "float2x2 f22 = float2x2(1, 2, 3, 4);" 1670 "half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);" 1671 "double4x2 d42 = double4x2(1, 2, 3, 4, 5, 6, 7, 8);", 1672 *SkSL::ShaderCapsFactory::Default(), 1673 "#version 400\n" 1674 "out vec4 sk_FragColor;\n" 1675 "float f = 1.0;\n" 1676 "float h = 2.0;\n" 1677 "double d = 3.0;\n" 1678 "vec2 f2 = vec2(1.0, 2.0);\n" 1679 "vec3 h3 = vec3(1.0, 2.0, 3.0);\n" 1680 "dvec4 d4 = dvec4(1.0, 2.0, 3.0, 4.0);\n" 1681 "mat2 f22 = mat2(1.0, 2.0, 3.0, 4.0);\n" 1682 "mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n" 1683 "dmat4x2 d42 = dmat4x2(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n"); 1684 test(r, 1685 "float f = 1;" 1686 "half h = 2;" 1687 "float2 f2 = float2(1, 2);" 1688 "half3 h3 = half3(1, 2, 3);" 1689 "float2x2 f22 = float2x2(1, 2, 3, 4);" 1690 "half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);", 1691 *SkSL::ShaderCapsFactory::UsesPrecisionModifiers(), 1692 "#version 400\n" 1693 "precision mediump float;\n" 1694 "out mediump vec4 sk_FragColor;\n" 1695 "highp float f = 1.0;\n" 1696 "mediump float h = 2.0;\n" 1697 "highp vec2 f2 = vec2(1.0, 2.0);\n" 1698 "mediump vec3 h3 = vec3(1.0, 2.0, 3.0);\n" 1699 "highp mat2 f22 = mat2(1.0, 2.0, 3.0, 4.0);\n" 1700 "mediump mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n"); 1701 } 1702 1703 DEF_TEST(SkSLNumberConversions, r) { 1704 test(r, 1705 "short s = short(sqrt(1));" 1706 "int i = int(sqrt(1));" 1707 "ushort us = ushort(sqrt(1));" 1708 "uint ui = uint(sqrt(1));" 1709 "half h = sqrt(1);" 1710 "float f = sqrt(1);" 1711 "short s2s = s;" 1712 "short i2s = i;" 1713 "short us2s = short(us);" 1714 "short ui2s = short(ui);" 1715 "short h2s = short(h);" 1716 "short f2s = short(f);" 1717 "int s2i = s;" 1718 "int i2i = i;" 1719 "int us2i = int(us);" 1720 "int ui2i = int(ui);" 1721 "int h2i = int(h);" 1722 "int f2i = int(f);" 1723 "ushort s2us = ushort(s);" 1724 "ushort i2us = ushort(i);" 1725 "ushort us2us = us;" 1726 "ushort ui2us = ui;" 1727 "ushort h2us = ushort(h);" 1728 "ushort f2us = ushort(f);" 1729 "uint s2ui = uint(s);" 1730 "uint i2ui = uint(i);" 1731 "uint us2ui = us;" 1732 "uint ui2ui = ui;" 1733 "uint h2ui = uint(h);" 1734 "uint f2ui = uint(f);" 1735 "float s2f = s;" 1736 "float i2f = i;" 1737 "float us2f = us;" 1738 "float ui2f = ui;" 1739 "float h2f = h;" 1740 "float f2f = f;", 1741 *SkSL::ShaderCapsFactory::Default(), 1742 "#version 400\n" 1743 "out vec4 sk_FragColor;\n" 1744 "int s = int(sqrt(1.0));\n" 1745 "int i = int(sqrt(1.0));\n" 1746 "uint us = uint(sqrt(1.0));\n" 1747 "uint ui = uint(sqrt(1.0));\n" 1748 "float h = sqrt(1.0);\n" 1749 "float f = sqrt(1.0);\n" 1750 "int s2s = s;\n" 1751 "int i2s = i;\n" 1752 "int us2s = int(us);\n" 1753 "int ui2s = int(ui);\n" 1754 "int h2s = int(h);\n" 1755 "int f2s = int(f);\n" 1756 "int s2i = s;\n" 1757 "int i2i = i;\n" 1758 "int us2i = int(us);\n" 1759 "int ui2i = int(ui);\n" 1760 "int h2i = int(h);\n" 1761 "int f2i = int(f);\n" 1762 "uint s2us = uint(s);\n" 1763 "uint i2us = uint(i);\n" 1764 "uint us2us = us;\n" 1765 "uint ui2us = ui;\n" 1766 "uint h2us = uint(h);\n" 1767 "uint f2us = uint(f);\n" 1768 "uint s2ui = uint(s);\n" 1769 "uint i2ui = uint(i);\n" 1770 "uint us2ui = us;\n" 1771 "uint ui2ui = ui;\n" 1772 "uint h2ui = uint(h);\n" 1773 "uint f2ui = uint(f);\n" 1774 "float s2f = float(s);\n" 1775 "float i2f = float(i);\n" 1776 "float us2f = float(us);\n" 1777 "float ui2f = float(ui);\n" 1778 "float h2f = h;\n" 1779 "float f2f = f;\n"); 1780 } 1781 1782 DEF_TEST(SkSLForceHighPrecision, r) { 1783 test(r, 1784 "void main() { half x = sqrt(1); half4 y = half4(x); sk_FragColor = y; }", 1785 *SkSL::ShaderCapsFactory::UsesPrecisionModifiers(), 1786 "#version 400\n" 1787 "precision mediump float;\n" 1788 "out mediump vec4 sk_FragColor;\n" 1789 "void main() {\n" 1790 " mediump float x = sqrt(1.0);\n" 1791 " mediump vec4 y = vec4(x);\n" 1792 " sk_FragColor = y;\n" 1793 "}\n"); 1794 SkSL::Program::Settings settings; 1795 settings.fForceHighPrecision = true; 1796 sk_sp<GrShaderCaps> caps = SkSL::ShaderCapsFactory::UsesPrecisionModifiers(); 1797 settings.fCaps = caps.get(); 1798 SkSL::Program::Inputs inputs; 1799 test(r, 1800 "void main() { half x = sqrt(1); half4 y = half4(x); sk_FragColor = y; }", 1801 settings, 1802 "#version 400\n" 1803 "precision mediump float;\n" 1804 "out mediump vec4 sk_FragColor;\n" 1805 "void main() {\n" 1806 " highp float x = sqrt(1.0);\n" 1807 " highp vec4 y = vec4(x);\n" 1808 " sk_FragColor = y;\n" 1809 "}\n", 1810 &inputs); 1811 } 1812 1813 DEF_TEST(SkSLNormalization, r) { 1814 test(r, 1815 "uniform float4 sk_RTAdjust; void main() { sk_Position = half4(1); }", 1816 *SkSL::ShaderCapsFactory::Default(), 1817 "#version 400\n" 1818 "uniform vec4 sk_RTAdjust;\n" 1819 "void main() {\n" 1820 " gl_Position = vec4(1.0);\n" 1821 " gl_Position = vec4(gl_Position.x * sk_RTAdjust.x + gl_Position.w * sk_RTAdjust.y, " 1822 "gl_Position.y * sk_RTAdjust.z + gl_Position.w * sk_RTAdjust.w, " 1823 "0.0, " 1824 "gl_Position.w);\n" 1825 "}\n", 1826 SkSL::Program::kVertex_Kind); 1827 test(r, 1828 "uniform float4 sk_RTAdjust;" 1829 "layout(points) in;" 1830 "layout(invocations = 2) in;" 1831 "layout(line_strip, max_vertices = 2) out;" 1832 "void main() {" 1833 "sk_Position = sk_in[0].sk_Position + float4(-0.5, 0, 0, sk_InvocationID);" 1834 "EmitVertex();" 1835 "sk_Position = sk_in[0].sk_Position + float4(0.5, 0, 0, sk_InvocationID);" 1836 "EmitVertex();" 1837 "EndPrimitive();" 1838 "}", 1839 *SkSL::ShaderCapsFactory::GeometryShaderSupport(), 1840 "#version 400\n" 1841 "uniform vec4 sk_RTAdjust;\n" 1842 "layout (points) in ;\n" 1843 "layout (invocations = 2) in ;\n" 1844 "layout (line_strip, max_vertices = 2) out ;\n" 1845 "void main() {\n" 1846 " gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, float(gl_InvocationID));\n" 1847 " {\n" 1848 " gl_Position = vec4(gl_Position.x * sk_RTAdjust.x + gl_Position.w * " 1849 "sk_RTAdjust.y, gl_Position.y * sk_RTAdjust.z + gl_Position.w * " 1850 "sk_RTAdjust.w, 0.0, gl_Position.w);\n" 1851 " EmitVertex();\n" 1852 " }\n" 1853 " gl_Position = gl_in[0].gl_Position + vec4(0.5, 0.0, 0.0, float(gl_InvocationID));\n" 1854 " {\n" 1855 " gl_Position = vec4(gl_Position.x * sk_RTAdjust.x + gl_Position.w * " 1856 "sk_RTAdjust.y, gl_Position.y * sk_RTAdjust.z + gl_Position.w * " 1857 "sk_RTAdjust.w, 0.0, gl_Position.w);\n" 1858 " EmitVertex();\n" 1859 " }\n" 1860 " EndPrimitive();\n" 1861 "}\n", 1862 SkSL::Program::kGeometry_Kind); 1863 } 1864 1865 DEF_TEST(SkSLTernaryLValue, r) { 1866 test(r, 1867 "void main() { half r, g; (true ? r : g) = 1; (false ? r : g) = 0; " 1868 "sk_FragColor = half4(r, g, 1, 1); }", 1869 *SkSL::ShaderCapsFactory::Default(), 1870 "#version 400\n" 1871 "out vec4 sk_FragColor;\n" 1872 "void main() {\n" 1873 " sk_FragColor = vec4(1.0, 0.0, 1.0, 1.0);\n" 1874 "}\n"); 1875 test(r, 1876 "void main() { half r, g; (true ? r : g) = sqrt(1); (false ? r : g) = sqrt(0); " 1877 "sk_FragColor = half4(r, g, 1, 1); }", 1878 *SkSL::ShaderCapsFactory::Default(), 1879 "#version 400\n" 1880 "out vec4 sk_FragColor;\n" 1881 "void main() {\n" 1882 " float r, g;\n" 1883 " r = sqrt(1.0);\n" 1884 " g = sqrt(0.0);\n" 1885 " sk_FragColor = vec4(r, g, 1.0, 1.0);\n" 1886 "}\n"); 1887 test(r, 1888 "void main() {" 1889 "half r, g;" 1890 "(sqrt(1) > 0 ? r : g) = sqrt(1);" 1891 "(sqrt(0) > 0 ? r : g) = sqrt(0);" 1892 "sk_FragColor = half4(r, g, 1, 1);" 1893 "}", 1894 *SkSL::ShaderCapsFactory::Default(), 1895 "#version 400\n" 1896 "out vec4 sk_FragColor;\n" 1897 "void main() {\n" 1898 " float r, g;\n" 1899 " sqrt(1.0) > 0.0 ? r : g = sqrt(1.0);\n" 1900 " sqrt(0.0) > 0.0 ? r : g = sqrt(0.0);\n" 1901 " sk_FragColor = vec4(r, g, 1.0, 1.0);\n" 1902 "}\n"); 1903 } 1904 1905 #endif 1906
