1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2015-2016 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ /*! 20 * \file 21 * \brief 22 */ /*-------------------------------------------------------------------*/ 23 24 /* Includes. */ 25 #include "gl4cES31CompatibilityTests.hpp" 26 #include "gluContextInfo.hpp" 27 #include "gluDefs.hpp" 28 #include "gluRenderContext.hpp" 29 #include "gluStrUtil.hpp" 30 #include "tcuTestLog.hpp" 31 32 /******************************** Test Group Implementation ********************************/ 33 34 /** @brief ES3.1 Compatibility tests group constructor. 35 * 36 * @param [in] context OpenGL context. 37 */ 38 gl4cts::es31compatibility::Tests::Tests(deqp::Context& context) 39 : TestCaseGroup(context, "es_31_compatibility", "ES3.1 Compatibility Test Suite") 40 { 41 /* Intentionally left blank */ 42 } 43 44 /** @brief ES3.1 Compatibility Tests initializer. */ 45 void gl4cts::es31compatibility::Tests::init() 46 { 47 /* New tests. */ 48 addChild(new gl4cts::es31compatibility::ShaderCompilationCompatibilityTests(m_context)); 49 addChild(new gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest(m_context)); 50 51 /* Ported tests. */ 52 addChild(new gl4cts::es31compatibility::SampleVariablesTests(m_context, glu::GLSL_VERSION_310_ES)); 53 addChild(new gl4cts::es31compatibility::ShaderImageLoadStoreTests(m_context)); 54 addChild(new gl4cts::es31compatibility::ShaderStorageBufferObjectTests(m_context)); 55 } 56 57 /******************************** Shader Compilation Compatibility Tests Implementation ********************************/ 58 59 /** @brief ShaderCompilationCompatibilityTests constructor. 60 * 61 * @param [in] context OpenGL context. 62 */ 63 gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::ShaderCompilationCompatibilityTests( 64 deqp::Context& context) 65 : deqp::TestCase(context, "shader_compilation", "Shader Compilation Compatibility Test") 66 { 67 } 68 69 /** @brief ShaderCompilationCompatibilityTests test cases iterations. 70 */ 71 tcu::TestNode::IterateResult gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::iterate() 72 { 73 /* Shortcut for GL functionality. */ 74 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 75 76 /* OpenGL support query. */ 77 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 78 bool is_arb_es31_compatibility = m_context.getContextInfo().isExtensionSupported("GL_ARB_ES3_1_compatibility"); 79 80 /* Running tests. */ 81 bool is_ok = true; 82 bool is_error = false; 83 84 glw::GLuint shader = 0; 85 86 /* Test */ 87 try 88 { 89 if (is_at_least_gl_45 || is_arb_es31_compatibility) 90 { 91 for (glw::GLsizei i = 0; i < s_shaders_count; ++i) 92 { 93 /* Shader compilation. */ 94 shader = gl.createShader(s_shaders[i].type); 95 96 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed."); 97 98 if (0 == shader) 99 { 100 throw 0; 101 } 102 103 gl.shaderSource(shader, 1, &(s_shaders[i].source), NULL); 104 105 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed."); 106 107 gl.compileShader(shader); 108 109 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed."); 110 111 /* Checking for errors. */ 112 glw::GLint status = GL_FALSE; 113 114 gl.getShaderiv(shader, GL_COMPILE_STATUS, &status); 115 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed."); 116 117 if (GL_FALSE == status) 118 { 119 /* Setup result. */ 120 is_ok = false; 121 122 /* Getting compilation informations. */ 123 glw::GLint log_size = 0; 124 125 gl.getShaderiv(shader, GL_INFO_LOG_LENGTH, &log_size); 126 127 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 128 129 if (log_size) 130 { 131 glw::GLchar* log = new glw::GLchar[log_size]; 132 133 if (log) 134 { 135 memset(log, 0, log_size); 136 137 gl.getShaderInfoLog(shader, log_size, DE_NULL, log); 138 139 /* Logging. */ 140 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Compilation of " 141 << s_shaders[i].type_name 142 << " shader have failed.\n Shader source was:\n" 143 << s_shaders[i].source << "\nCompillation log:\n" 144 << log << tcu::TestLog::EndMessage; 145 146 delete[] log; 147 148 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed."); 149 } 150 } 151 } 152 153 /* Cleanup. */ 154 gl.deleteShader(shader); 155 156 shader = 0; 157 158 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader call failed."); 159 } 160 } 161 } 162 catch (...) 163 { 164 is_ok = false; 165 is_error = true; 166 } 167 168 /* Cleanup. */ 169 if (0 != shader) 170 { 171 gl.deleteShader(shader); 172 173 shader = 0; 174 } 175 176 /* Result's setup and logging. */ 177 if (is_ok) 178 { 179 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 180 } 181 else 182 { 183 if (is_error) 184 { 185 m_context.getTestContext().getLog() << tcu::TestLog::Message 186 << "Internal error has occured during the Shader Version Test." 187 << tcu::TestLog::EndMessage; 188 189 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Test error."); 190 } 191 else 192 { 193 m_context.getTestContext().getLog() << tcu::TestLog::Message << "The Shader Version Test has failed." 194 << tcu::TestLog::EndMessage; 195 196 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 197 } 198 } 199 200 return STOP; 201 } 202 203 const gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::TestShader 204 gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::s_shaders[] = { 205 { /* Shader for testing ES 3.1 version string support.*/ 206 GL_VERTEX_SHADER, "vertex", "#version 310 es\n" 207 "\n" 208 "void main()\n" 209 "{\n" 210 " gl_Position = vec4(1.0);\n" 211 "}\n" }, 212 { /* Shader for testing ES 3.1 version string support.*/ 213 GL_FRAGMENT_SHADER, "fragment", "#version 310 es\n" 214 "\n" 215 "out highp vec4 color;" 216 "\n" 217 "void main()\n" 218 "{\n" 219 " color = vec4(1.0);\n" 220 "}\n" }, 221 { /* Shader for testing that gl_HelperInvocation variable is supported.*/ 222 GL_FRAGMENT_SHADER, "fragment", "#version 310 es\n" 223 "\n" 224 "out highp vec4 color;" 225 "\n" 226 "void main()\n" 227 "{\n" 228 " if(gl_HelperInvocation)\n" 229 " {\n" 230 " color = vec4(1.0);\n" 231 " }\n" 232 " else\n" 233 " {\n" 234 " color = vec4(0.0);\n" 235 " }\n" 236 "}\n" }, 237 { /* Shader for testing ES 3.1 version string support.*/ 238 GL_COMPUTE_SHADER, "compute", 239 "#version 310 es\n" 240 "\n" 241 "layout(local_size_x = 128) in;\n" 242 "layout(std140, binding = 0) buffer Output\n" 243 "{\n" 244 " uint elements[];\n" 245 "} output_data;\n" 246 "\n" 247 "void main()\n" 248 "{\n" 249 " output_data.elements[gl_GlobalInvocationID.x] = gl_GlobalInvocationID.x * gl_GlobalInvocationID.x;\n" 250 "}\n" } 251 }; 252 253 const glw::GLsizei gl4cts::es31compatibility::ShaderCompilationCompatibilityTests::s_shaders_count = 254 sizeof(s_shaders) / sizeof(s_shaders[0]); 255 256 /******************************** Shader Functional Compatibility Test Implementation ********************************/ 257 258 /** @brief Shader Functional Compatibility Test constructor. 259 * 260 * @param [in] context OpenGL context. 261 */ 262 gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::ShaderFunctionalCompatibilityTest(deqp::Context& context) 263 : deqp::TestCase(context, "shader_functional", "Shader Functional Compatibility Test") 264 , m_po_id(0) 265 , m_fbo_id(0) 266 , m_rbo_id(0) 267 , m_vao_id(0) 268 { 269 } 270 271 /** @brief ShaderCompilationCompatibilityTests test cases iterations. 272 */ 273 tcu::TestNode::IterateResult gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::iterate() 274 { 275 /* OpenGL support query. */ 276 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 277 bool is_arb_es31_compatibility = m_context.getContextInfo().isExtensionSupported("GL_ARB_ES3_1_compatibility"); 278 279 /* Running tests. */ 280 bool is_ok = true; 281 bool is_error = false; 282 283 /* Test */ 284 try 285 { 286 if (is_at_least_gl_45 || is_arb_es31_compatibility) 287 { 288 createFramebufferAndVertexArrayObject(); 289 290 for (glw::GLsizei i = 0; i < s_shaders_count; ++i) 291 { 292 if (!createProgram(s_shaders[i])) 293 { 294 is_ok = false; 295 296 continue; /* if createProgram failed we shall omit this iteration */ 297 } 298 299 is_ok &= test(); 300 301 cleanProgram(); 302 } 303 304 cleanFramebufferAndVertexArrayObject(); 305 } 306 } 307 catch (...) 308 { 309 /* Result setup. */ 310 is_ok = false; 311 is_error = true; 312 313 /* Cleanup. */ 314 cleanProgram(); 315 cleanFramebufferAndVertexArrayObject(); 316 } 317 318 /* Result's setup. */ 319 if (is_ok) 320 { 321 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 322 } 323 else 324 { 325 if (is_error) 326 { 327 m_context.getTestContext().getLog() << tcu::TestLog::Message 328 << "Internal error has occured during the Shader Version Test." 329 << tcu::TestLog::EndMessage; 330 331 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Test error."); 332 } 333 else 334 { 335 m_context.getTestContext().getLog() << tcu::TestLog::Message << "The Shader Version Test has failed." 336 << tcu::TestLog::EndMessage; 337 338 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 339 } 340 } 341 342 return STOP; 343 } 344 345 /** @brief Create program object 346 * 347 * @note Program object is going to be stored into m_po_id. 348 * If building succeeded program will be set current (glUseProgram). 349 * 350 * @param [in] shader_source Shader source to be builded. 351 * 352 * @return True if succeeded, false otherwise. 353 */ 354 bool gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::createProgram(const struct Shader shader_source) 355 { 356 /* Shortcut for GL functionality. */ 357 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 358 359 struct _Shader 360 { 361 const glw::GLchar* const* source; 362 const glw::GLenum type; 363 glw::GLuint id; 364 } shader[] = { { shader_source.vertex, GL_VERTEX_SHADER, 0 }, { shader_source.fragment, GL_FRAGMENT_SHADER, 0 } }; 365 366 glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]); 367 368 try 369 { 370 /* Make sure m_po_id is cleaned. */ 371 if (m_po_id) 372 { 373 cleanProgram(); 374 } 375 376 /* Create program. */ 377 m_po_id = gl.createProgram(); 378 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed."); 379 380 /* Shader compilation. */ 381 382 for (glw::GLuint i = 0; i < shader_count; ++i) 383 { 384 if (DE_NULL != shader[i].source) 385 { 386 shader[i].id = gl.createShader(shader[i].type); 387 388 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed."); 389 390 gl.attachShader(m_po_id, shader[i].id); 391 392 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader call failed."); 393 394 gl.shaderSource(shader[i].id, 3, shader[i].source, NULL); 395 396 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed."); 397 398 gl.compileShader(shader[i].id); 399 400 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed."); 401 402 glw::GLint status = GL_FALSE; 403 404 gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status); 405 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed."); 406 407 if (GL_FALSE == status) 408 { 409 glw::GLint log_size = 0; 410 411 gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size); 412 413 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); 414 415 if (log_size) 416 { 417 glw::GLchar* log = new glw::GLchar[log_size]; 418 419 if (log) 420 { 421 memset(log, 0, log_size); 422 423 gl.getShaderInfoLog(shader[i].id, log_size, DE_NULL, log); 424 425 m_context.getTestContext().getLog() 426 << tcu::TestLog::Message << "Compilation of shader has failed.\nShader source:\n" 427 << shader[i].source[0] << shader[i].source[1] << shader[i].source[2] 428 << "\nCompillation log:\n" 429 << log << tcu::TestLog::EndMessage; 430 431 delete[] log; 432 433 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed."); 434 } 435 } 436 437 throw 0; 438 } 439 } 440 } 441 442 /* Link. */ 443 gl.linkProgram(m_po_id); 444 445 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram call failed."); 446 447 glw::GLint status = GL_FALSE; 448 449 gl.getProgramiv(m_po_id, GL_LINK_STATUS, &status); 450 451 if (GL_TRUE == status) 452 { 453 for (glw::GLuint i = 0; i < shader_count; ++i) 454 { 455 if (shader[i].id) 456 { 457 gl.detachShader(m_po_id, shader[i].id); 458 459 GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed."); 460 } 461 } 462 } 463 else 464 { 465 glw::GLint log_size = 0; 466 467 gl.getProgramiv(m_po_id, GL_INFO_LOG_LENGTH, &log_size); 468 469 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); 470 471 if (log_size) 472 { 473 glw::GLchar* log = new glw::GLchar[log_size]; 474 475 if (log) 476 { 477 memset(log, 0, log_size); 478 479 gl.getProgramInfoLog(m_po_id, log_size, DE_NULL, log); 480 481 m_context.getTestContext().getLog() << tcu::TestLog::Message 482 << "Linkage of shader program has failed.\nLinkage log:\n" 483 << log << tcu::TestLog::EndMessage; 484 485 delete[] log; 486 487 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed."); 488 } 489 } 490 491 throw 0; 492 } 493 } 494 catch (...) 495 { 496 if (m_po_id) 497 { 498 gl.deleteProgram(m_po_id); 499 500 m_po_id = 0; 501 } 502 } 503 504 for (glw::GLuint i = 0; i < shader_count; ++i) 505 { 506 if (0 != shader[i].id) 507 { 508 gl.deleteShader(shader[i].id); 509 510 shader[i].id = 0; 511 } 512 } 513 514 if (m_po_id) 515 { 516 gl.useProgram(m_po_id); 517 518 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed."); 519 520 return true; 521 } 522 523 return false; 524 } 525 526 /** @brief Create framebuffer and vertex array object. 527 * 528 * @note Frembuffer will be stored in m_fbo_id and m_rbo_id. 529 * Vertex array object will be stored in m_vao_id. 530 * Function will throw 0 if erro has occured. 531 */ 532 void gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::createFramebufferAndVertexArrayObject() 533 { 534 /* Shortcut for GL functionality. */ 535 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 536 537 /* Prepare framebuffer. */ 538 gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f); 539 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed."); 540 541 gl.genFramebuffers(1, &m_fbo_id); 542 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed."); 543 544 gl.genRenderbuffers(1, &m_rbo_id); 545 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed."); 546 547 gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); 548 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed."); 549 550 gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo_id); 551 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed."); 552 553 gl.renderbufferStorage(GL_RENDERBUFFER, GL_R8, 1 /* x size */, 1 /* y size */); 554 GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed."); 555 556 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo_id); 557 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed."); 558 559 /* Check if all went ok. */ 560 if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) 561 { 562 throw 0; 563 } 564 565 /* View Setup. */ 566 gl.viewport(0, 0, 1 /* x size */, 1 /* y size */); 567 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed."); 568 569 /* Create and bind empty vertex array object. */ 570 gl.genVertexArrays(1, &m_vao_id); 571 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); 572 573 if (0 == m_vao_id) 574 { 575 throw 0; 576 } 577 578 gl.bindVertexArray(m_vao_id); 579 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); 580 } 581 582 /** @brief Run test case. 583 * 584 * @note Test case run in following order: 585 * * clear screen with 0 value (color setup in createFramebufferAndVertexArrayObject); 586 * * draw full screen quad; 587 * * fetch pixel from screen using glReadPixel (view is 1x1 pixel in size); 588 * * compare results (1.0f is expected as the result of the shader). 589 */ 590 bool gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::test() 591 { 592 /* Shortcut for GL functionality. */ 593 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 594 595 /* Make sure objects are cleaned. */ 596 if (m_fbo_id || m_rbo_id || m_vao_id) 597 { 598 cleanFramebufferAndVertexArrayObject(); 599 } 600 601 /* Drawing quad which shall output result. */ 602 gl.clear(GL_COLOR_BUFFER_BIT); 603 GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed."); 604 605 gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4); 606 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); 607 608 /* Fetching result. */ 609 glw::GLfloat red = -1.f; 610 611 gl.readPixels(0, 0, 1, 1, GL_RED, GL_FLOAT, &red); 612 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed."); 613 614 if (de::abs(1.f - red) <= 0.125 /* Precision. */) 615 { 616 return true; 617 } 618 619 return false; 620 } 621 622 /** @brief Release program object. 623 */ 624 void gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::cleanProgram() 625 { 626 /* Shortcut for GL functionality. */ 627 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 628 629 /* Deleting program. */ 630 if (m_po_id) 631 { 632 gl.useProgram(0); 633 634 gl.deleteProgram(m_po_id); 635 636 m_po_id = 0; 637 } 638 } 639 640 /** @brief Release framebuffer, renderbuffer and vertex array objects. 641 */ 642 void gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::cleanFramebufferAndVertexArrayObject() 643 { 644 /* Shortcut for GL functionality. */ 645 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 646 647 /* Deleting view. */ 648 if (m_fbo_id) 649 { 650 gl.deleteFramebuffers(1, &m_fbo_id); 651 652 m_fbo_id = 0; 653 } 654 655 if (m_rbo_id) 656 { 657 gl.deleteRenderbuffers(1, &m_rbo_id); 658 659 m_rbo_id = 0; 660 } 661 662 if (m_vao_id) 663 { 664 gl.deleteVertexArrays(1, &m_vao_id); 665 666 m_vao_id = 0; 667 } 668 } 669 670 const glw::GLchar* gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_shader_version = "#version 310 es\n"; 671 672 const glw::GLchar* gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_vertex_shader_body = 673 "\n" 674 "out highp float dummy;\n" 675 "\n" 676 "void main()\n" 677 "{\n" 678 " switch(gl_VertexID % 4)\n" 679 " {\n" 680 " case 0:\n" 681 " gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n" 682 " break;\n" 683 " case 1:\n" 684 " gl_Position = vec4( 1.0, -1.0, 0.0, 1.0);\n" 685 " break;\n" 686 " case 2:\n" 687 " gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n" 688 " break;\n" 689 " case 3:\n" 690 " gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n" 691 " break;\n" 692 " }\n" 693 "\n" 694 " dummy = float(gl_VertexID % 4);\n /* Always less than 4. */" 695 "}\n"; 696 697 const glw::GLchar* gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_fragment_shader_body = 698 "\n" 699 "in highp float dummy;\n" 700 "\n" 701 "out highp vec4 result;\n" 702 "\n" 703 "void main()\n" 704 "{\n" 705 " TTYPE a = LEFT;\n" 706 " TTYPE b = RIGHT;\n" 707 " BTYPE c = BDATA && BTYPE(dummy < 4.0);\n /* Making sure that expression is not compile time constant. */" 708 "\n" 709 " TTYPE mixed = mix(a, b, c);\n" 710 "\n" 711 " if(REFERENCE == mixed)\n" 712 " {\n" 713 " result = vec4(1.0);\n" 714 " }\n" 715 " else\n" 716 " {\n" 717 " result = vec4(0.0);\n" 718 " }\n" 719 "}\n"; 720 721 const struct gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::Shader 722 gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_shaders[] = { 723 { { s_shader_version, "", s_vertex_shader_body }, 724 { s_shader_version, "#define TTYPE highp int\n" 725 "#define BTYPE bool\n" 726 "#define LEFT -1\n" 727 "#define RIGHT -2\n" 728 "#define BDATA true\n" 729 "#define REFERENCE -2\n", 730 s_fragment_shader_body } }, 731 { { s_shader_version, "", s_vertex_shader_body }, 732 { s_shader_version, "#define TTYPE highp uint\n" 733 "#define BTYPE bool\n" 734 "#define LEFT 1u\n" 735 "#define RIGHT 2u\n" 736 "#define BDATA true\n" 737 "#define REFERENCE 2u\n", 738 s_fragment_shader_body } }, 739 { { s_shader_version, "", s_vertex_shader_body }, 740 { s_shader_version, "#define TTYPE mediump int\n" 741 "#define BTYPE bool\n" 742 "#define LEFT -1\n" 743 "#define RIGHT -2\n" 744 "#define BDATA true\n" 745 "#define REFERENCE -2\n", 746 s_fragment_shader_body } }, 747 { { s_shader_version, "", s_vertex_shader_body }, 748 { s_shader_version, "#define TTYPE mediump uint\n" 749 "#define BTYPE bool\n" 750 "#define LEFT 1u\n" 751 "#define RIGHT 2u\n" 752 "#define BDATA true\n" 753 "#define REFERENCE 2u\n", 754 s_fragment_shader_body } }, 755 { { s_shader_version, "", s_vertex_shader_body }, 756 { s_shader_version, "#define TTYPE lowp int\n" 757 "#define BTYPE bool\n" 758 "#define LEFT -1\n" 759 "#define RIGHT -2\n" 760 "#define BDATA true\n" 761 "#define REFERENCE -2\n", 762 s_fragment_shader_body } }, 763 { { s_shader_version, "", s_vertex_shader_body }, 764 { s_shader_version, "#define TTYPE lowp uint\n" 765 "#define BTYPE bool\n" 766 "#define LEFT 1u\n" 767 "#define RIGHT 2u\n" 768 "#define BDATA true\n" 769 "#define REFERENCE 2u\n", 770 s_fragment_shader_body } }, 771 { { s_shader_version, "", s_vertex_shader_body }, 772 { s_shader_version, "#define TTYPE bool\n" 773 "#define BTYPE bool\n" 774 "#define LEFT false\n" 775 "#define RIGHT true\n" 776 "#define BDATA true\n" 777 "#define REFERENCE true\n", 778 s_fragment_shader_body } }, 779 { { s_shader_version, "", s_vertex_shader_body }, 780 { s_shader_version, "#define TTYPE highp ivec2\n" 781 "#define BTYPE bvec2\n" 782 "#define LEFT ivec2(-1, -2)\n" 783 "#define RIGHT ivec2(-3, -4)\n" 784 "#define BDATA bvec2(true, false)\n" 785 "#define REFERENCE ivec2(-3, -2)\n", 786 s_fragment_shader_body } }, 787 { { s_shader_version, "", s_vertex_shader_body }, 788 { s_shader_version, "#define TTYPE highp uvec2\n" 789 "#define BTYPE bvec2\n" 790 "#define LEFT uvec2(1, 2)\n" 791 "#define RIGHT uvec2(3, 4)\n" 792 "#define BDATA bvec2(true, false)\n" 793 "#define REFERENCE uvec2(3, 2)\n", 794 s_fragment_shader_body } }, 795 { { s_shader_version, "", s_vertex_shader_body }, 796 { s_shader_version, "#define TTYPE mediump ivec2\n" 797 "#define BTYPE bvec2\n" 798 "#define LEFT ivec2(-1, -2)\n" 799 "#define RIGHT ivec2(-3, -4)\n" 800 "#define BDATA bvec2(true, false)\n" 801 "#define REFERENCE ivec2(-3, -2)\n", 802 s_fragment_shader_body } }, 803 { { s_shader_version, "", s_vertex_shader_body }, 804 { s_shader_version, "#define TTYPE mediump uvec2\n" 805 "#define BTYPE bvec2\n" 806 "#define LEFT uvec2(1, 2)\n" 807 "#define RIGHT uvec2(3, 4)\n" 808 "#define BDATA bvec2(true, false)\n" 809 "#define REFERENCE uvec2(3, 2)\n", 810 s_fragment_shader_body } }, 811 { { s_shader_version, "", s_vertex_shader_body }, 812 { s_shader_version, "#define TTYPE lowp ivec2\n" 813 "#define BTYPE bvec2\n" 814 "#define LEFT ivec2(-1, -2)\n" 815 "#define RIGHT ivec2(-3, -4)\n" 816 "#define BDATA bvec2(true, false)\n" 817 "#define REFERENCE ivec2(-3, -2)\n", 818 s_fragment_shader_body } }, 819 { { s_shader_version, "", s_vertex_shader_body }, 820 { s_shader_version, "#define TTYPE lowp uvec2\n" 821 "#define BTYPE bvec2\n" 822 "#define LEFT uvec2(1, 2)\n" 823 "#define RIGHT uvec2(3, 4)\n" 824 "#define BDATA bvec2(true, false)\n" 825 "#define REFERENCE uvec2(3, 2)\n", 826 s_fragment_shader_body } }, 827 { { s_shader_version, "", s_vertex_shader_body }, 828 { s_shader_version, "#define TTYPE bvec2\n" 829 "#define BTYPE bvec2\n" 830 "#define LEFT bvec2(true, true)\n" 831 "#define RIGHT bvec2(false, false)\n" 832 "#define BDATA bvec2(true, false)\n" 833 "#define REFERENCE bvec2(false, true)\n", 834 s_fragment_shader_body } }, 835 { { s_shader_version, "", s_vertex_shader_body }, 836 { s_shader_version, "#define TTYPE highp ivec3\n" 837 "#define BTYPE bvec3\n" 838 "#define LEFT ivec3(-1, -2, -3)\n" 839 "#define RIGHT ivec3(-4, -5, -6)\n" 840 "#define BDATA bvec3(true, false, true)\n" 841 "#define REFERENCE ivec3(-4, -2, -6)\n", 842 s_fragment_shader_body } }, 843 { { s_shader_version, "", s_vertex_shader_body }, 844 { s_shader_version, "#define TTYPE highp uvec3\n" 845 "#define BTYPE bvec3\n" 846 "#define LEFT uvec3(1, 2, 3)\n" 847 "#define RIGHT uvec3(4, 5, 6)\n" 848 "#define BDATA bvec3(true, false, true)\n" 849 "#define REFERENCE uvec3(4, 2, 6)\n", 850 s_fragment_shader_body } }, 851 { { s_shader_version, "", s_vertex_shader_body }, 852 { s_shader_version, "#define TTYPE mediump ivec3\n" 853 "#define BTYPE bvec3\n" 854 "#define LEFT ivec3(-1, -2, -3)\n" 855 "#define RIGHT ivec3(-4, -5, -6)\n" 856 "#define BDATA bvec3(true, false, true)\n" 857 "#define REFERENCE ivec3(-4, -2, -6)\n", 858 s_fragment_shader_body } }, 859 { { s_shader_version, "", s_vertex_shader_body }, 860 { s_shader_version, "#define TTYPE mediump uvec3\n" 861 "#define BTYPE bvec3\n" 862 "#define LEFT uvec3(1, 2, 3)\n" 863 "#define RIGHT uvec3(4, 5, 6)\n" 864 "#define BDATA bvec3(true, false, true)\n" 865 "#define REFERENCE uvec3(4, 2, 6)\n", 866 s_fragment_shader_body } }, 867 { { s_shader_version, "", s_vertex_shader_body }, 868 { s_shader_version, "#define TTYPE lowp ivec3\n" 869 "#define BTYPE bvec3\n" 870 "#define LEFT ivec3(-1, -2, -3)\n" 871 "#define RIGHT ivec3(-4, -5, -6)\n" 872 "#define BDATA bvec3(true, false, true)\n" 873 "#define REFERENCE ivec3(-4, -2, -6)\n", 874 s_fragment_shader_body } }, 875 { { s_shader_version, "", s_vertex_shader_body }, 876 { s_shader_version, "#define TTYPE lowp uvec3\n" 877 "#define BTYPE bvec3\n" 878 "#define LEFT uvec3(1, 2, 3)\n" 879 "#define RIGHT uvec3(4, 5, 6)\n" 880 "#define BDATA bvec3(true, false, true)\n" 881 "#define REFERENCE uvec3(4, 2, 6)\n", 882 s_fragment_shader_body } }, 883 { { s_shader_version, "", s_vertex_shader_body }, 884 { s_shader_version, "#define TTYPE bvec3\n" 885 "#define BTYPE bvec3\n" 886 "#define LEFT bvec3(true, true, true)\n" 887 "#define RIGHT bvec3(false, false, false)\n" 888 "#define BDATA bvec3(true, false, true)\n" 889 "#define REFERENCE bvec3(false, true, false)\n", 890 s_fragment_shader_body } }, 891 { { s_shader_version, "", s_vertex_shader_body }, 892 { s_shader_version, "#define TTYPE highp ivec4\n" 893 "#define BTYPE bvec4\n" 894 "#define LEFT ivec4(-1, -2, -3, -4)\n" 895 "#define RIGHT ivec4(-5, -6, -7, -8)\n" 896 "#define BDATA bvec4(true, false, true, false)\n" 897 "#define REFERENCE ivec4(-5, -2, -7, -4)\n", 898 s_fragment_shader_body } }, 899 { { s_shader_version, "", s_vertex_shader_body }, 900 { s_shader_version, "#define TTYPE highp uvec4\n" 901 "#define BTYPE bvec4\n" 902 "#define LEFT uvec4(1, 2, 3, 4)\n" 903 "#define RIGHT uvec4(5, 6, 7, 8)\n" 904 "#define BDATA bvec4(true, false, true, false)\n" 905 "#define REFERENCE uvec4(5, 2, 7, 4)\n", 906 s_fragment_shader_body } }, 907 { { s_shader_version, "", s_vertex_shader_body }, 908 { s_shader_version, "#define TTYPE mediump ivec4\n" 909 "#define BTYPE bvec4\n" 910 "#define LEFT ivec4(-1, -2, -3, -4)\n" 911 "#define RIGHT ivec4(-5, -6, -7, -8)\n" 912 "#define BDATA bvec4(true, false, true, false)\n" 913 "#define REFERENCE ivec4(-5, -2, -7, -4)\n", 914 s_fragment_shader_body } }, 915 { { s_shader_version, "", s_vertex_shader_body }, 916 { s_shader_version, "#define TTYPE mediump uvec4\n" 917 "#define BTYPE bvec4\n" 918 "#define LEFT uvec4(1, 2, 3, 4)\n" 919 "#define RIGHT uvec4(5, 6, 7, 8)\n" 920 "#define BDATA bvec4(true, false, true, false)\n" 921 "#define REFERENCE uvec4(5, 2, 7, 4)\n", 922 s_fragment_shader_body } }, 923 { { s_shader_version, "", s_vertex_shader_body }, 924 { s_shader_version, "#define TTYPE lowp ivec4\n" 925 "#define BTYPE bvec4\n" 926 "#define LEFT ivec4(-1, -2, -3, -4)\n" 927 "#define RIGHT ivec4(-5, -6, -7, -8)\n" 928 "#define BDATA bvec4(true, false, true, false)\n" 929 "#define REFERENCE ivec4(-5, -2, -7, -4)\n", 930 s_fragment_shader_body } }, 931 { { s_shader_version, "", s_vertex_shader_body }, 932 { s_shader_version, "#define TTYPE lowp uvec4\n" 933 "#define BTYPE bvec4\n" 934 "#define LEFT uvec4(1, 2, 3, 4)\n" 935 "#define RIGHT uvec4(5, 6, 7, 8)\n" 936 "#define BDATA bvec4(true, false, true, false)\n" 937 "#define REFERENCE uvec4(5, 2, 7, 4)\n", 938 s_fragment_shader_body } }, 939 { { s_shader_version, "", s_vertex_shader_body }, 940 { s_shader_version, "#define TTYPE bvec4\n" 941 "#define BTYPE bvec4\n" 942 "#define LEFT bvec4(true, true, true, true)\n" 943 "#define RIGHT bvec4(false, false, false, false)\n" 944 "#define BDATA bvec4(true, false, true, false)\n" 945 "#define REFERENCE bvec4(false, true, false, true)\n", 946 s_fragment_shader_body } } 947 }; 948 949 const glw::GLsizei gl4cts::es31compatibility::ShaderFunctionalCompatibilityTest::s_shaders_count = 950 sizeof(s_shaders) / sizeof(s_shaders[0]); 951
