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 /** 25 * \file gl3cTextureSizePromotionTests.hpp 26 * \brief Implements test classes for testing of texture internal format 27 promotion mechanism. 28 */ /*-------------------------------------------------------------------*/ 29 30 #include "gl3cTextureSizePromotion.hpp" 31 32 #include "deMath.h" 33 #include "gluContextInfo.hpp" 34 #include "gluStrUtil.hpp" 35 #include "glwFunctions.hpp" 36 #include "tcuTestLog.hpp" 37 38 /* Stringify macro. */ 39 #define _STR(s) STR(s) 40 #define STR(s) #s 41 42 namespace gl3cts 43 { 44 namespace TextureSizePromotion 45 { 46 Tests::Tests(deqp::Context& context) 47 : TestCaseGroup(context, "texture_size_promotion", "Verifies texture internal format size promotion mechanism.") 48 { 49 /* Left blank on purpose */ 50 } 51 52 void Tests::init(void) 53 { 54 addChild(new TextureSizePromotion::FunctionalTest(m_context)); 55 } 56 57 /*===========================================================================================================*/ 58 59 FunctionalTest::FunctionalTest(deqp::Context& context) 60 : TestCase(context, "functional", "Verifies that texture internal format size promotion mechanism can be used.") 61 , m_vao(0) 62 , m_source_texture(0) 63 , m_destination_texture(0) 64 , m_framebuffer(0) 65 , m_program(0) 66 , m_max_samples(0) 67 { 68 /* Left blank on purpose */ 69 } 70 71 tcu::TestNode::IterateResult FunctionalTest::iterate() 72 { 73 /* Get context setup. */ 74 glu::ContextType context_type = m_context.getRenderContext().getType(); 75 bool is_arb_texture_storage_multisample = 76 m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_storage_multisample"); 77 78 /* Prepare initial results. */ 79 bool is_ok = true; 80 bool was_error = false; 81 82 /* Iterate over test cases. */ 83 try 84 { 85 /* Only for OpenGL 3.1 context. */ 86 if (glu::contextSupports(context_type, glu::ApiType::core(3, 1))) 87 { 88 /* Generate and bind VAO. */ 89 prepareVertexArrayObject(); 90 91 /* For every required format */ 92 for (glw::GLuint i = 0; i < s_formats_size; ++i) 93 { 94 /* Test only if format is required by context. */ 95 if (glu::contextSupports(context_type, s_formats[i].required_by_context.getAPI())) 96 { 97 /* For every target. */ 98 for (glw::GLuint j = 0; j < s_source_texture_targets_count; ++j) 99 { 100 /* Test if it is supported by context or internal format. */ 101 if (isTargetMultisampled(s_source_texture_targets[j])) 102 { 103 if ((!is_arb_texture_storage_multisample) && 104 (!glu::contextSupports(context_type, glu::ApiType::core(4, 3)))) 105 { 106 continue; 107 } 108 109 if (!s_formats[i] 110 .is_color_renderable) /* Multisampled textures need to be set using rendering. */ 111 { 112 continue; 113 } 114 115 if (isDepthType(s_formats[i]) || isStencilType(s_formats[i])) 116 { 117 continue; 118 } 119 } 120 121 if ((isDepthType(s_formats[i]) || isStencilType(s_formats[i])) && 122 (GL_TEXTURE_3D == s_source_texture_targets[j])) 123 { 124 continue; 125 } 126 127 /* Prepare source texture to be tested. */ 128 prepareSourceTexture(s_formats[i], s_source_texture_targets[j]); 129 130 /* Check basic API queries for source texture. */ 131 is_ok = is_ok & checkSourceTextureSizeAndType(s_formats[i], s_source_texture_targets[j]); 132 133 /* For every [R, G, B, A] component. */ 134 for (glw::GLuint k = 0; k < COMPONENTS_COUNT; ++k) 135 { 136 /* Prepare destination texture. */ 137 prepareDestinationTextureAndFramebuffer(s_formats[i], GL_TEXTURE_2D); 138 139 /* Building program (throws on failure). */ 140 m_program = 141 prepareProgram(s_source_texture_targets[j], s_formats[i], ColorChannelSelector(k)); 142 143 /* Setup GL and draw. */ 144 makeProgramAndSourceTextureActive(s_source_texture_targets[j]); 145 146 drawQuad(); 147 148 /* Check results. */ 149 is_ok = is_ok & checkDestinationTexture(s_formats[i], ColorChannelSelector(k), 150 s_source_texture_targets[j], 151 s_source_texture_targets_names[j]); 152 153 /* Cleanup. */ 154 cleanDestinationTexture(); 155 cleanFramebuffer(); 156 cleanProgram(); 157 } 158 159 cleanSourceTexture(); 160 } 161 } 162 } 163 } 164 } 165 catch (...) 166 { 167 /* Error have occured. */ 168 is_ok = false; 169 was_error = true; 170 } 171 172 /* Clean all. */ 173 174 cleanSourceTexture(); 175 cleanDestinationTexture(); 176 cleanFramebuffer(); 177 cleanProgram(); 178 cleanVertexArrayObject(); 179 180 /* Result's setup. */ 181 if (is_ok) 182 { 183 /* Log success. */ 184 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Texture Size Promotion Test have passed." 185 << tcu::TestLog::EndMessage; 186 187 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 188 } 189 else 190 { 191 if (was_error) 192 { 193 /* Log error. */ 194 m_context.getTestContext().getLog() << tcu::TestLog::Message 195 << "Texture Size Promotion Test have approached error." 196 << tcu::TestLog::EndMessage; 197 198 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 199 } 200 else 201 { 202 /* Log fail. */ 203 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Texture Size Promotion Test have failed." 204 << tcu::TestLog::EndMessage; 205 206 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 207 } 208 } 209 210 /* End test. */ 211 return tcu::TestNode::STOP; 212 } 213 214 void FunctionalTest::prepareVertexArrayObject() 215 { 216 /* GL functions object. */ 217 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 218 219 gl.genVertexArrays(1, &m_vao); 220 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays have failed"); 221 222 gl.bindVertexArray(m_vao); 223 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray have failed"); 224 } 225 226 void FunctionalTest::prepareSourceTexture(TextureInternalFormatDescriptor descriptor, glw::GLenum target) 227 { 228 /* GL functions object. */ 229 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 230 231 /* Create and bind texture object. */ 232 gl.genTextures(1, &m_source_texture); 233 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 234 235 gl.bindTexture(target, m_source_texture); 236 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 237 238 /* Select proper data set. */ 239 glw::GLvoid* source_data = DE_NULL; 240 glw::GLenum source_type = GL_NONE; 241 glw::GLenum source_format = GL_RGBA; 242 243 if (isFloatType(descriptor)) /* For floating type. */ 244 { 245 source_data = (glw::GLvoid*)s_source_texture_data_f; 246 source_type = GL_FLOAT; 247 source_format = GL_RGBA; 248 } 249 else 250 { 251 if (isFixedSignedType(descriptor)) /* For fixed signed type. */ 252 { 253 source_data = (glw::GLvoid*)s_source_texture_data_sn; 254 source_type = GL_FLOAT; 255 source_format = GL_RGBA; 256 } 257 else 258 { 259 if (isFixedUnsignedType(descriptor)) /* For fixed unsigned type. */ 260 { 261 source_data = (glw::GLvoid*)s_source_texture_data_n; 262 source_type = GL_FLOAT; 263 source_format = GL_RGBA; 264 } 265 else 266 { 267 if (isIntegerSignedType(descriptor)) /* For integral signed type. */ 268 { 269 source_data = (glw::GLvoid*)s_source_texture_data_i; 270 source_type = GL_INT; 271 source_format = GL_RGBA_INTEGER; 272 } 273 else 274 { 275 if (isIntegerUnsignedType(descriptor)) /* For integral unsigned type. */ 276 { 277 source_data = (glw::GLvoid*)s_source_texture_data_ui; 278 source_type = GL_UNSIGNED_INT; 279 source_format = GL_RGBA_INTEGER; 280 } 281 else 282 { 283 if (isDepthType(descriptor)) /* For depth type. */ 284 { 285 source_data = NULL; 286 source_type = GL_UNSIGNED_INT; 287 source_format = GL_DEPTH_COMPONENT; 288 } 289 else 290 { 291 if (isStencilType(descriptor)) /* For stencil type. */ 292 { 293 source_data = NULL; 294 source_type = GL_UNSIGNED_INT; 295 source_format = GL_STENCIL_INDEX; 296 } 297 } 298 } 299 } 300 } 301 } 302 } 303 304 /* Prepare texture storage depending on the target. */ 305 switch (target) 306 { 307 case GL_TEXTURE_1D: 308 gl.texImage1D(target, 0, descriptor.internal_format, s_source_texture_size, 0, source_format, source_type, 309 source_data); 310 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 311 break; 312 case GL_TEXTURE_1D_ARRAY: 313 case GL_TEXTURE_2D: 314 case GL_TEXTURE_RECTANGLE: 315 gl.texImage2D(target, 0, descriptor.internal_format, s_source_texture_size, s_source_texture_size, 0, 316 source_format, source_type, source_data); 317 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 318 break; 319 case GL_TEXTURE_2D_ARRAY: 320 case GL_TEXTURE_3D: 321 gl.texImage3D(target, 0, descriptor.internal_format, s_source_texture_size, s_source_texture_size, 322 s_source_texture_size, 0, source_format, source_type, source_data); 323 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 324 break; 325 case GL_TEXTURE_2D_MULTISAMPLE: 326 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: 327 renderDataIntoMultisampledTexture(descriptor, target); 328 break; 329 default: 330 throw 0; 331 } 332 } 333 334 void FunctionalTest::renderDataIntoMultisampledTexture(TextureInternalFormatDescriptor descriptor, glw::GLenum target) 335 { 336 /* GL functions object. */ 337 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 338 339 /* Fetch limits. */ 340 gl.getIntegerv(GL_MAX_SAMPLES, &m_max_samples); 341 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv have failed"); 342 343 if (m_max_samples == 0) 344 { 345 m_max_samples = 1; 346 } 347 348 /* Setup target. */ 349 glw::GLenum non_ms_target = (target == GL_TEXTURE_2D_MULTISAMPLE) ? GL_TEXTURE_2D : GL_TEXTURE_2D_ARRAY; 350 351 /* Cleanup required by prepareSourceTexture(...). */ 352 cleanSourceTexture(); 353 354 /* Prepare textures and program. */ 355 prepareSourceTexture(descriptor, non_ms_target); 356 357 prepareDestinationTextureAndFramebuffer(descriptor, target); 358 359 m_program = prepareProgram(non_ms_target, descriptor, COMPONENTS_COUNT); 360 361 /* Setup GL and render texture. */ 362 makeProgramAndSourceTextureActive(non_ms_target); 363 364 drawQuad(); 365 366 /* Cleanup. */ 367 cleanFramebuffer(); 368 cleanSourceTexture(); 369 370 /* Swpaing destination texture to source texture. */ 371 m_source_texture = m_destination_texture; 372 373 m_destination_texture = 0; 374 375 /* Clean program. */ 376 cleanProgram(); 377 } 378 379 void FunctionalTest::prepareDestinationTextureAndFramebuffer(TextureInternalFormatDescriptor descriptor, 380 glw::GLenum target) 381 { 382 /* GL functions object. */ 383 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 384 385 /* Get internal format. */ 386 glw::GLenum internal_format = getDestinationFormatForChannel(descriptor); 387 388 /* Create framebuffer object. */ 389 gl.genFramebuffers(1, &m_framebuffer); 390 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed."); 391 392 gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer); 393 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed."); 394 395 /* Create framebuffer's destination texture. */ 396 gl.genTextures(1, &m_destination_texture); 397 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 398 399 gl.bindTexture(target, m_destination_texture); 400 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 401 402 /* Allocate texture storage and upload data for test rendering. */ 403 if (target == GL_TEXTURE_2D) 404 { 405 glw::GLenum destination_format = GL_RED; 406 glw::GLenum destination_type = GL_FLOAT; 407 glw::GLvoid* destination_data = (glw::GLvoid*)s_destination_texture_data_f; 408 409 if (isIntegerSignedType(descriptor)) 410 { 411 destination_format = GL_RED_INTEGER; 412 destination_type = GL_INT; 413 destination_data = (glw::GLvoid*)s_destination_texture_data_i; 414 } 415 416 if (isIntegerUnsignedType(descriptor)) 417 { 418 destination_format = GL_RED_INTEGER; 419 destination_type = GL_UNSIGNED_INT; 420 destination_data = (glw::GLvoid*)s_destination_texture_data_ui; 421 } 422 423 gl.texImage2D(target, 0, internal_format, s_source_texture_size, s_source_texture_size, 0, destination_format, 424 destination_type, destination_data); 425 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 426 427 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_destination_texture, 0); 428 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D have failed"); 429 } 430 else /* Allocate texture storage for uploading datat for multisampled targets (upload must be done via shader). */ 431 { 432 if (target == GL_TEXTURE_2D_MULTISAMPLE) 433 { 434 gl.texImage2DMultisample(target, m_max_samples - 1, descriptor.internal_format, s_source_texture_size, 435 s_source_texture_size, GL_TRUE); 436 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 437 438 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_destination_texture, 0); 439 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D have failed"); 440 } 441 else 442 { 443 gl.texImage3DMultisample(target, m_max_samples - 1, descriptor.internal_format, s_source_texture_size, 444 s_source_texture_size, s_source_texture_size, GL_TRUE); 445 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 446 447 gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_destination_texture, 0, 0); 448 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D have failed"); 449 } 450 } 451 452 /* Check framebuffer completness. */ 453 if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) 454 { 455 throw 0; 456 } 457 458 /* Setup viewport. */ 459 gl.viewport(0, 0, s_source_texture_size, s_source_texture_size); 460 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed."); 461 } 462 463 void FunctionalTest::makeProgramAndSourceTextureActive(glw::GLenum target) 464 { 465 /* GL functions object. */ 466 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 467 468 /* Use GLSL program. */ 469 gl.useProgram(m_program); 470 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram have failed"); 471 472 /* Setup source texture. */ 473 gl.activeTexture(GL_TEXTURE0); 474 GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture have failed"); 475 476 gl.bindTexture(target, m_source_texture); 477 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 478 479 glw::GLint location = gl.getUniformLocation(m_program, "data"); 480 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation have failed"); 481 482 gl.uniform1i(location, 0); 483 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i have failed"); 484 } 485 486 bool FunctionalTest::checkSourceTextureSizeAndType(TextureInternalFormatDescriptor descriptor, glw::GLenum target) 487 { 488 /* GL functions object. */ 489 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 490 491 /* query result storage */ 492 glw::GLint red_size = 0; 493 glw::GLint blue_size = 0; 494 glw::GLint green_size = 0; 495 glw::GLint alpha_size = 0; 496 glw::GLint depth_size = 0; 497 glw::GLint stencil_size = 0; 498 499 glw::GLint red_type = 0; 500 glw::GLint green_type = 0; 501 glw::GLint blue_type = 0; 502 glw::GLint alpha_type = 0; 503 glw::GLint depth_type = 0; 504 505 /* Bind texture */ 506 gl.bindTexture(target, m_source_texture); 507 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 508 509 /* queries */ 510 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_RED_SIZE, &red_size); 511 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_GREEN_SIZE, &green_size); 512 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_BLUE_SIZE, &blue_size); 513 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_ALPHA_SIZE, &alpha_size); 514 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_DEPTH_SIZE, &depth_size); 515 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_STENCIL_SIZE, &stencil_size); 516 517 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_RED_TYPE, &red_type); 518 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_GREEN_TYPE, &green_type); 519 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_BLUE_TYPE, &blue_type); 520 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_ALPHA_TYPE, &alpha_type); 521 gl.getTexLevelParameteriv(target, 0, GL_TEXTURE_DEPTH_TYPE, &depth_type); 522 523 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv have failed"); 524 525 /* check expected values */ 526 bool is_ok = true; 527 528 is_ok = is_ok && (red_size >= descriptor.min_red_size); 529 is_ok = is_ok && (green_size >= descriptor.min_green_size); 530 is_ok = is_ok && (blue_size >= descriptor.min_blue_size); 531 is_ok = is_ok && (alpha_size >= descriptor.min_alpha_size); 532 is_ok = is_ok && (depth_size >= descriptor.min_depth_size); 533 is_ok = is_ok && (stencil_size >= descriptor.min_stencil_size); 534 535 is_ok = is_ok && ((glw::GLenum)red_type == descriptor.expected_red_type); 536 is_ok = is_ok && ((glw::GLenum)green_type == descriptor.expected_green_type); 537 is_ok = is_ok && ((glw::GLenum)blue_type == descriptor.expected_blue_type); 538 is_ok = is_ok && ((glw::GLenum)alpha_type == descriptor.expected_alpha_type); 539 is_ok = is_ok && ((glw::GLenum)depth_type == descriptor.expected_depth_type); 540 541 /* Log on failure. */ 542 if (!is_ok) 543 { 544 m_context.getTestContext().getLog() 545 << tcu::TestLog::Message << "Promotion from internal format " << descriptor.internal_format_name 546 << " have failed during glGetTexLevelParameteriv query. " 547 << "Expected red size = " << descriptor.min_red_size 548 << ", expected green size = " << descriptor.min_green_size 549 << ", expected blue size = " << descriptor.min_blue_size 550 << ", expected alpha size = " << descriptor.min_alpha_size 551 << ", expected depth size = " << descriptor.min_depth_size 552 << ", expected stencil size = " << descriptor.min_stencil_size << ". Queried red size = " << red_size 553 << ", queried green size = " << green_size << ", queried blue size = " << blue_size 554 << ", queried alpha size = " << alpha_size << ", queried depth size = " << depth_size 555 << ", queried stencil size = " << stencil_size << ". " 556 << "Expected red type = " << glu::getTypeStr(descriptor.expected_red_type) 557 << ", expected green type = " << glu::getTypeStr(descriptor.expected_green_type) 558 << ", expected blue type = " << glu::getTypeStr(descriptor.expected_blue_type) 559 << ", expected alpha type = " << glu::getTypeStr(descriptor.expected_alpha_type) 560 << ", expected depth type = " << glu::getTypeStr(descriptor.expected_depth_type) 561 << ". Queried red type = " << glu::getTypeStr(red_type) 562 << ", queried green type = " << glu::getTypeStr(green_type) 563 << ", queried blue type = " << glu::getTypeStr(blue_type) 564 << ", queried alpha type = " << glu::getTypeStr(alpha_type) 565 << ", queried depth type = " << glu::getTypeStr(depth_type) << "." << tcu::TestLog::EndMessage; 566 } 567 568 /* return results. */ 569 return is_ok; 570 } 571 572 glw::GLenum FunctionalTest::getDestinationFormatForChannel(TextureInternalFormatDescriptor descriptor) 573 { 574 if (isFloatType(descriptor)) 575 { 576 return GL_R32F; 577 } 578 579 if (isFixedUnsignedType(descriptor)) 580 { 581 return GL_R16; 582 } 583 584 if (isFixedSignedType(descriptor)) 585 { 586 return GL_R16_SNORM; 587 } 588 589 if (isIntegerUnsignedType(descriptor)) 590 { 591 return GL_R32UI; 592 } 593 594 if (isIntegerSignedType(descriptor)) 595 { 596 return GL_R32I; 597 } 598 599 return GL_R32F; 600 } 601 602 glw::GLuint FunctionalTest::prepareProgram(glw::GLenum target, TextureInternalFormatDescriptor descriptor, 603 ColorChannelSelector channel) 604 { 605 /* GL functions object. */ 606 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 607 608 /* Preparing sampler name and textelFetch arguments */ 609 std::string sampler_name = ""; 610 std::string texel_fetch_arguments_tail = ""; 611 612 switch (target) 613 { 614 case GL_TEXTURE_1D: 615 sampler_name = "sampler1D"; 616 texel_fetch_arguments_tail = "0, 0"; 617 break; 618 case GL_TEXTURE_2D: 619 sampler_name = "sampler2D"; 620 texel_fetch_arguments_tail = "ivec2(0), 0"; 621 break; 622 case GL_TEXTURE_1D_ARRAY: 623 sampler_name = "sampler1DArray"; 624 texel_fetch_arguments_tail = "ivec2(0), 0"; 625 break; 626 case GL_TEXTURE_RECTANGLE: 627 sampler_name = "sampler2DRect"; 628 texel_fetch_arguments_tail = "ivec2(0)"; 629 break; 630 case GL_TEXTURE_2D_ARRAY: 631 sampler_name = "sampler2DArray"; 632 texel_fetch_arguments_tail = "ivec3(0), 0"; 633 break; 634 case GL_TEXTURE_3D: 635 sampler_name = "sampler3D"; 636 texel_fetch_arguments_tail = "ivec3(0), 0"; 637 break; 638 case GL_TEXTURE_2D_MULTISAMPLE: 639 sampler_name = "sampler2DMS"; 640 texel_fetch_arguments_tail = "ivec2(0), "; 641 texel_fetch_arguments_tail.append(Utilities::itoa(m_max_samples - 1)); 642 break; 643 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: 644 sampler_name = "sampler2DMSArray"; 645 texel_fetch_arguments_tail = "ivec3(0), "; 646 texel_fetch_arguments_tail.append(Utilities::itoa(m_max_samples - 1)); 647 break; 648 default: 649 throw 0; 650 } 651 652 /* Preparing component selector name */ 653 std::string component_name = ""; 654 655 switch (channel) 656 { 657 case RED_COMPONENT: 658 component_name = ".r"; 659 break; 660 case GREEN_COMPONENT: 661 component_name = ".g"; 662 break; 663 case BLUE_COMPONENT: 664 component_name = ".b"; 665 break; 666 case ALPHA_COMPONENT: 667 component_name = ".a"; 668 break; 669 case COMPONENTS_COUNT: 670 break; 671 default: 672 throw 0; 673 } 674 675 /* Preparing output type name and sampler prefix */ 676 std::string type_name = ""; 677 std::string sampler_prefix = ""; 678 679 if (isFloatType(descriptor) || isFixedSignedType(descriptor) || isFixedUnsignedType(descriptor) || 680 isDepthType(descriptor) || isStencilType(descriptor)) 681 { 682 if (channel == COMPONENTS_COUNT) 683 { 684 type_name = "vec4"; 685 } 686 else 687 { 688 type_name = "float"; 689 } 690 sampler_prefix = ""; 691 } 692 else 693 { 694 if (isIntegerSignedType(descriptor)) 695 { 696 if (channel == COMPONENTS_COUNT) 697 { 698 type_name = "ivec4"; 699 } 700 else 701 { 702 type_name = "int"; 703 } 704 sampler_prefix = "i"; 705 } 706 else 707 { 708 if (channel == COMPONENTS_COUNT) 709 { 710 type_name = "uvec4"; 711 } 712 else 713 { 714 type_name = "uint"; 715 } 716 sampler_prefix = "u"; 717 } 718 } 719 720 std::string template_verison = "#version 150"; 721 722 /* Preprocessing fragment shader source code. */ 723 std::string fragment_shader = s_fragment_shader_template; 724 725 fragment_shader = Utilities::preprocessString(fragment_shader, "TEMPLATE_TYPE", type_name); 726 fragment_shader = 727 Utilities::preprocessString(fragment_shader, "TEMPLATE_SAMPLER", sampler_prefix.append(sampler_name)); 728 fragment_shader = 729 Utilities::preprocessString(fragment_shader, "TEMPLATE_TEXEL_FETCH_ARGUMENTS", texel_fetch_arguments_tail); 730 fragment_shader = Utilities::preprocessString(fragment_shader, "TEMPLATE_COMPONENT", component_name); 731 732 /* Building program. */ 733 glw::GLuint program = 734 Utilities::buildProgram(gl, m_context.getTestContext().getLog(), s_vertex_shader_code, fragment_shader.c_str()); 735 736 if (0 == program) 737 { 738 throw 0; 739 } 740 741 /* Return program name. */ 742 return program; 743 } 744 745 void FunctionalTest::drawQuad() 746 { 747 /* GL functions object. */ 748 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 749 750 /* Draw quad. */ 751 gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4); 752 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays have failed"); 753 } 754 755 void FunctionalTest::cleanSourceTexture() 756 { 757 /* GL functions object. */ 758 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 759 760 /* Delete object. */ 761 if (m_source_texture) 762 { 763 gl.deleteTextures(1, &m_source_texture); 764 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteTextures have failed"); 765 766 m_source_texture = 0; 767 } 768 } 769 770 void FunctionalTest::cleanDestinationTexture() 771 { 772 /* GL functions object. */ 773 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 774 775 /* Delete object. */ 776 if (m_destination_texture) 777 { 778 gl.deleteTextures(1, &m_destination_texture); 779 780 m_destination_texture = 0; 781 } 782 } 783 784 void FunctionalTest::cleanFramebuffer() 785 { 786 /* GL functions object. */ 787 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 788 789 /* Delete object. */ 790 if (m_framebuffer) 791 { 792 gl.deleteFramebuffers(1, &m_framebuffer); 793 794 m_framebuffer = 0; 795 } 796 } 797 798 void FunctionalTest::cleanProgram() 799 { 800 /* GL functions object. */ 801 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 802 803 /* Delete object. */ 804 if (m_program) 805 { 806 gl.useProgram(0); 807 808 gl.deleteProgram(m_program); 809 810 m_program = 0; 811 } 812 } 813 814 void FunctionalTest::cleanVertexArrayObject() 815 { 816 /* GL functions object. */ 817 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 818 819 /* Delete object. */ 820 if (m_vao) 821 { 822 gl.deleteVertexArrays(1, &m_vao); 823 824 m_vao = 0; 825 } 826 } 827 828 bool FunctionalTest::checkDestinationTexture(TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel, 829 glw::GLenum target, const glw::GLchar* target_name) 830 { 831 /* GL functions object. */ 832 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 833 834 /* Check depending on format. */ 835 if (isFloatType(descriptor) || isDepthType(descriptor) || isStencilType(descriptor)) 836 { 837 /* Fetch results from destination texture (attached to current framebuffer). */ 838 glw::GLfloat pixel = 3.1415927f; 839 gl.readPixels(0, 0, 1, 1, GL_RED, GL_FLOAT, &pixel); 840 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels have failed"); 841 842 /* Setup expected value. */ 843 glw::GLfloat expected_value = isChannelTypeNone(descriptor, channel) ? 844 ((channel == ALPHA_COMPONENT) ? 1.f : 0.f) : 845 s_source_texture_data_f[channel]; 846 847 /* Compare expected and fetched values. */ 848 if (fabs(pixel - expected_value) <= getMinPrecision(descriptor, channel)) 849 { 850 /* Test succeeded*/ 851 return true; 852 } 853 else 854 { 855 /* Log failure. */ 856 m_context.getTestContext().getLog() 857 << tcu::TestLog::Message << "Promotion from internal format " << descriptor.internal_format_name 858 << " have failed during functional test of " << s_color_channel_names[channel] 859 << " channel with target " << target_name << ". Expected value = " << expected_value 860 << " read value = " << pixel << "." << tcu::TestLog::EndMessage; 861 } 862 } 863 else 864 { 865 if (isFixedSignedType(descriptor)) 866 { 867 /* Fetch results from destination texture (attached to current framebuffer). */ 868 glw::GLfloat pixel = 3.1415927f; 869 gl.readPixels(0, 0, 1, 1, GL_RED, GL_FLOAT, &pixel); 870 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels have failed"); 871 872 /* Setup expected value. */ 873 /* Signed fixed-point read color are clamped to [0, 1] by default */ 874 glw::GLfloat expected_value = isChannelTypeNone(descriptor, channel) ? 875 ((channel == ALPHA_COMPONENT) ? 1.f : 0.f) : 876 deFloatClamp(s_source_texture_data_sn[channel], 0, 1); 877 878 /* Compare expected and fetched values. */ 879 if (fabs(pixel - expected_value) <= getMinPrecision(descriptor, channel)) 880 { 881 /* Test succeeded*/ 882 return true; 883 } 884 else 885 { 886 /* Log failure. */ 887 m_context.getTestContext().getLog() 888 << tcu::TestLog::Message << "Promotion from internal format " << descriptor.internal_format_name 889 << " have failed during functional test of " << s_color_channel_names[channel] 890 << " channel with target " << target_name << ". Expected value = " << expected_value 891 << " read value = " << pixel << "." << tcu::TestLog::EndMessage; 892 } 893 } 894 else 895 { 896 if (isFixedUnsignedType(descriptor)) 897 { 898 /* Fetch results from destination texture (attached to current framebuffer). */ 899 glw::GLfloat pixel = 3.1415927f; 900 gl.readPixels(0, 0, 1, 1, GL_RED, GL_FLOAT, &pixel); 901 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels have failed"); 902 903 /* Setup expected value. */ 904 glw::GLfloat expected_value = isChannelTypeNone(descriptor, channel) ? 905 ((channel == ALPHA_COMPONENT) ? 1.f : 0.f) : 906 s_source_texture_data_n[channel]; 907 908 /* For sRGB internal formats convert value to linear space. */ 909 if (descriptor.is_sRGB && (channel < ALPHA_COMPONENT)) 910 { 911 expected_value = convert_from_sRGB(expected_value); 912 913 if (isTargetMultisampled( 914 target)) /* In multisampled targets two conversions are made (in upload and in shader) */ 915 { 916 expected_value = convert_from_sRGB(expected_value); 917 } 918 } 919 920 /* Compare expected and fetched values. */ 921 if (fabs(pixel - expected_value) <= getMinPrecision(descriptor, channel)) 922 { 923 /* Test succeeded*/ 924 return true; 925 } 926 else 927 { 928 /* Log failure. */ 929 m_context.getTestContext().getLog() 930 << tcu::TestLog::Message << "Promotion from internal format " << descriptor.internal_format_name 931 << " have failed during functional test of " << s_color_channel_names[channel] 932 << " channel with target " << target_name << ". Expected value = " << expected_value 933 << " read value = " << pixel << "." << tcu::TestLog::EndMessage; 934 } 935 } 936 else 937 { 938 if (isIntegerSignedType(descriptor)) 939 { 940 /* Fetch results from destination texture (attached to current framebuffer). */ 941 glw::GLint pixel = 5; 942 gl.readPixels(0, 0, 1, 1, GL_RED_INTEGER, GL_INT, &pixel); 943 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels have failed"); 944 945 /* Setup expected value. */ 946 glw::GLint expected_value = isChannelTypeNone(descriptor, channel) ? 947 ((channel == ALPHA_COMPONENT) ? 1 : 0) : 948 s_source_texture_data_i[channel]; 949 950 /* Compare expected and fetched values. */ 951 if (pixel == expected_value) 952 { 953 /* Test succeeded*/ 954 return true; 955 } 956 else 957 { 958 /* Log failure. */ 959 m_context.getTestContext().getLog() 960 << tcu::TestLog::Message << "Promotion from internal format " 961 << descriptor.internal_format_name << " have failed during functional test of " 962 << s_color_channel_names[channel] << " channel with target " << target_name 963 << ". Expected value = " << expected_value << " read value = " << pixel << "." 964 << tcu::TestLog::EndMessage; 965 } 966 } 967 else 968 { 969 if (isIntegerUnsignedType(descriptor)) 970 { 971 /* Fetch results from destination texture (attached to current framebuffer). */ 972 glw::GLuint pixel = 5; 973 gl.readPixels(0, 0, 1, 1, GL_RED_INTEGER, GL_UNSIGNED_INT, &pixel); 974 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels have failed"); 975 976 /* Setup expected value. */ 977 glw::GLuint expected_value = isChannelTypeNone(descriptor, channel) ? 978 ((channel == ALPHA_COMPONENT) ? 1 : 0) : 979 s_source_texture_data_ui[channel]; 980 981 /* Compare expected and fetched values. */ 982 if (pixel == expected_value) 983 { 984 /* Test succeeded*/ 985 return true; 986 } 987 else 988 { 989 /* Log failure. */ 990 m_context.getTestContext().getLog() 991 << tcu::TestLog::Message << "Promotion from internal format " 992 << descriptor.internal_format_name << " have failed during functional test of " 993 << s_color_channel_names[channel] << " channel with target " << target_name 994 << ". Expected value = " << expected_value << " read value = " << pixel << "." 995 << tcu::TestLog::EndMessage; 996 } 997 } 998 } 999 } 1000 } 1001 } 1002 1003 /* Test failed. */ 1004 return false; 1005 } 1006 1007 bool FunctionalTest::isFloatType(TextureInternalFormatDescriptor descriptor) 1008 { 1009 return (GL_FLOAT == descriptor.expected_red_type) || (GL_FLOAT == descriptor.expected_green_type) || 1010 (GL_FLOAT == descriptor.expected_blue_type) || (GL_FLOAT == descriptor.expected_alpha_type); 1011 } 1012 1013 bool FunctionalTest::isFixedSignedType(TextureInternalFormatDescriptor descriptor) 1014 { 1015 return (GL_SIGNED_NORMALIZED == descriptor.expected_red_type) || 1016 (GL_SIGNED_NORMALIZED == descriptor.expected_green_type) || 1017 (GL_SIGNED_NORMALIZED == descriptor.expected_blue_type) || 1018 (GL_SIGNED_NORMALIZED == descriptor.expected_alpha_type); 1019 } 1020 1021 bool FunctionalTest::isFixedUnsignedType(TextureInternalFormatDescriptor descriptor) 1022 { 1023 return (GL_UNSIGNED_NORMALIZED == descriptor.expected_red_type) || 1024 (GL_UNSIGNED_NORMALIZED == descriptor.expected_green_type) || 1025 (GL_UNSIGNED_NORMALIZED == descriptor.expected_blue_type) || 1026 (GL_UNSIGNED_NORMALIZED == descriptor.expected_alpha_type); 1027 } 1028 1029 bool FunctionalTest::isIntegerSignedType(TextureInternalFormatDescriptor descriptor) 1030 { 1031 return (GL_INT == descriptor.expected_red_type) || (GL_INT == descriptor.expected_green_type) || 1032 (GL_INT == descriptor.expected_blue_type) || (GL_INT == descriptor.expected_alpha_type); 1033 } 1034 1035 bool FunctionalTest::isIntegerUnsignedType(TextureInternalFormatDescriptor descriptor) 1036 { 1037 return (GL_UNSIGNED_INT == descriptor.expected_red_type) || (GL_UNSIGNED_INT == descriptor.expected_green_type) || 1038 (GL_UNSIGNED_INT == descriptor.expected_blue_type) || (GL_UNSIGNED_INT == descriptor.expected_alpha_type); 1039 } 1040 1041 bool FunctionalTest::isDepthType(TextureInternalFormatDescriptor descriptor) 1042 { 1043 return (GL_NONE != descriptor.expected_depth_type); 1044 } 1045 1046 bool FunctionalTest::isStencilType(TextureInternalFormatDescriptor descriptor) 1047 { 1048 return (descriptor.min_stencil_size > 0); 1049 } 1050 1051 bool FunctionalTest::isChannelTypeNone(TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel) 1052 { 1053 switch (channel) 1054 { 1055 case RED_COMPONENT: 1056 return (GL_NONE == descriptor.expected_red_type); 1057 case GREEN_COMPONENT: 1058 return (GL_NONE == descriptor.expected_green_type); 1059 case BLUE_COMPONENT: 1060 return (GL_NONE == descriptor.expected_blue_type); 1061 case ALPHA_COMPONENT: 1062 return (GL_NONE == descriptor.expected_alpha_type); 1063 default: 1064 throw 0; 1065 } 1066 1067 return false; 1068 } 1069 1070 glw::GLfloat FunctionalTest::getMinPrecision(TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel) 1071 { 1072 /* Select channel data. */ 1073 glw::GLenum type = GL_NONE; 1074 glw::GLuint size = 0; 1075 1076 switch (channel) 1077 { 1078 case RED_COMPONENT: 1079 type = descriptor.expected_red_type; 1080 size = descriptor.min_red_size; 1081 break; 1082 case GREEN_COMPONENT: 1083 type = descriptor.expected_green_type; 1084 size = descriptor.min_green_size; 1085 break; 1086 case BLUE_COMPONENT: 1087 type = descriptor.expected_blue_type; 1088 size = descriptor.min_blue_size; 1089 break; 1090 case ALPHA_COMPONENT: 1091 type = descriptor.expected_alpha_type; 1092 size = descriptor.min_alpha_size; 1093 break; 1094 default: 1095 throw 0; 1096 } 1097 1098 /* If it is empty channel. */ 1099 if ((type == GL_NONE) || (size == 0)) 1100 { 1101 return 0.1f; 1102 } 1103 1104 /* If float type. */ 1105 if (isFloatType(descriptor)) 1106 { 1107 switch (size) 1108 { 1109 case 32: 1110 return 0.00001f; /* specification GL4.5 core constant */ 1111 case 16: 1112 return 1.f / 1024.f; /* specification GL4.5 core 10 bit mantisa constant */ 1113 case 11: 1114 return 1.f / 64.f; /* specification GL4.5 core 6 bit mantisa constant */ 1115 case 10: 1116 return 1.f / 32.f; /* specification GL4.5 core 5 bit mantisa constant */ 1117 default: 1118 return 0.00001f; 1119 } 1120 } 1121 1122 /* Fixed types precision */ 1123 if (isFixedSignedType(descriptor)) 1124 { 1125 return (float)(1.0 / pow(2.0, (double)(size - 1 /* sign bit */))); 1126 } 1127 1128 if (isFixedUnsignedType(descriptor)) 1129 { 1130 return (float)(1.0 / pow(2.0, (double)(size))); 1131 } 1132 1133 /* other aka (unsigned) integer */ 1134 return 1; 1135 } 1136 1137 bool FunctionalTest::isTargetMultisampled(glw::GLenum target) 1138 { 1139 return (GL_TEXTURE_2D_MULTISAMPLE == target) || (GL_TEXTURE_2D_MULTISAMPLE_ARRAY == target); 1140 } 1141 1142 float FunctionalTest::convert_from_sRGB(float value) 1143 { 1144 /* For reference check OpenGL specification (eg. OpenGL 4.5 core profile specification chapter 8.24 */ 1145 if (value > 0.04045f) 1146 { 1147 return deFloatPow((value + 0.055f) / 1.055f, 2.4f); 1148 } 1149 1150 return value / 12.92f; 1151 } 1152 1153 const glw::GLfloat FunctionalTest::s_source_texture_data_f[] = { 0.125f, 0.25f, 0.5f, 0.75f }; 1154 1155 const glw::GLfloat FunctionalTest::s_source_texture_data_n[] = { 0.125f, 0.25f, 0.5f, 0.75f }; 1156 1157 const glw::GLfloat FunctionalTest::s_source_texture_data_sn[] = { -0.125f, 0.25f, -0.5f, 0.75f }; 1158 1159 const glw::GLint FunctionalTest::s_source_texture_data_i[] = { -1, 2, -3, 4 }; 1160 1161 const glw::GLuint FunctionalTest::s_source_texture_data_ui[] = { 4, 3, 2, 1 }; 1162 1163 const glw::GLfloat FunctionalTest::s_destination_texture_data_f[] = { 1164 5.f 1165 }; /* False data for destination texture to be overwriten. */ 1166 1167 const glw::GLint FunctionalTest::s_destination_texture_data_i[] = { 1168 -5 1169 }; /* False data for destination texture to be overwriten. */ 1170 1171 const glw::GLuint FunctionalTest::s_destination_texture_data_ui[] = { 1172 5 1173 }; /* False data for destination texture to be overwriten. */ 1174 1175 const glw::GLenum FunctionalTest::s_source_texture_targets[] = { 1176 GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_RECTANGLE, 1177 GL_TEXTURE_2D_ARRAY, GL_TEXTURE_3D, GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY 1178 }; 1179 1180 const glw::GLchar* FunctionalTest::s_source_texture_targets_names[] = { 1181 STR(GL_TEXTURE_1D), STR(GL_TEXTURE_2D), STR(GL_TEXTURE_1D_ARRAY), STR(GL_TEXTURE_RECTANGLE), 1182 STR(GL_TEXTURE_2D_ARRAY), STR(GL_TEXTURE_3D), STR(GL_TEXTURE_2D_MULTISAMPLE), STR(GL_TEXTURE_2D_MULTISAMPLE_ARRAY) 1183 }; 1184 1185 const glw::GLuint FunctionalTest::s_source_texture_targets_count = 1186 sizeof(s_source_texture_targets) / sizeof(s_source_texture_targets[0]); 1187 1188 const glw::GLuint FunctionalTest::s_source_texture_size = 1; 1189 1190 const glw::GLchar* FunctionalTest::s_color_channel_names[] = { "red", "green", "blue", "alpha", "all" }; 1191 1192 const FunctionalTest::TextureInternalFormatDescriptor FunctionalTest::s_formats[] = { 1193 /* context version, internal format, internal format name, is sRGB, CR,size{R, G, B, A, D, S}, type of R, type of G, type of B, type of A, type of depth */ 1194 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R8, STR(GL_R8), false, true, 8, 0, 0, 0, 0, 0, 1195 GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1196 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_R8_SNORM, STR(GL_R8_SNORM), false, true, 8, 0, 0, 0, 0, 0, 1197 GL_SIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1198 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R16, STR(GL_R16), false, true, 16, 0, 0, 0, 0, 0, 1199 GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1200 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_R16_SNORM, STR(GL_R16_SNORM), false, true, 16, 0, 0, 0, 0, 0, 1201 GL_SIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1202 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG8, STR(GL_RG8), false, true, 8, 8, 0, 0, 0, 0, 1203 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE }, 1204 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_RG8_SNORM, STR(GL_RG8_SNORM), false, true, 8, 8, 0, 0, 0, 0, 1205 GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE }, 1206 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG16, STR(GL_RG16), false, true, 16, 16, 0, 0, 0, 0, 1207 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE }, 1208 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_RG16_SNORM, STR(GL_RG16_SNORM), false, true, 16, 16, 0, 0, 0, 0, 1209 GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_NONE, GL_NONE, GL_NONE }, 1210 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_R3_G3_B2, STR(GL_R3_G3_B2), false, true, 3, 3, 2, 0, 0, 0, 1211 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1212 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_RGB4, STR(GL_RGB4), false, true, 4, 4, 4, 0, 0, 0, 1213 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1214 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_RGB5, STR(GL_RGB5), false, true, 5, 5, 5, 0, 0, 0, 1215 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1216 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB8, STR(GL_RGB8), false, true, 8, 8, 8, 0, 0, 0, 1217 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1218 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_RGB8_SNORM, STR(GL_RGB8_SNORM), false, true, 8, 8, 8, 0, 0, 0, 1219 GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1220 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_RGB10, STR(GL_RGB10), false, true, 10, 10, 10, 0, 0, 0, 1221 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1222 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_RGB12, STR(GL_RGB12), false, true, 12, 12, 12, 0, 0, 0, 1223 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1224 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB16, STR(GL_RGB16), false, true, 16, 16, 16, 0, 0, 0, 1225 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1226 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_RGB16_SNORM, STR(GL_RGB16_SNORM), false, true, 16, 16, 16, 0, 0, 0, 1227 GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1228 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_RGBA2, STR(GL_RGBA2), false, true, 2, 2, 2, 2, 0, 0, 1229 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1230 { glu::ContextType(4, 2, glu::PROFILE_CORE), GL_RGBA4, STR(GL_RGBA4), false, true, 4, 4, 4, 4, 0, 0, 1231 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1232 { glu::ContextType(4, 2, glu::PROFILE_CORE), GL_RGB5_A1, STR(GL_RGB5_A1), false, true, 5, 5, 5, 1, 0, 0, 1233 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1234 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA8, STR(GL_RGBA8), false, true, 8, 8, 8, 8, 0, 0, 1235 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1236 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_RGBA8_SNORM, STR(GL_RGBA8_SNORM), false, true, 8, 8, 8, 8, 0, 0, 1237 GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_NONE }, 1238 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB10_A2, STR(GL_RGB10_A2), false, true, 10, 10, 10, 2, 0, 0, 1239 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1240 { glu::ContextType(3, 3, glu::PROFILE_CORE), GL_RGB10_A2UI, STR(GL_RGB10_A2UI), false, true, 10, 10, 10, 2, 0, 0, 1241 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE }, 1242 { glu::ContextType(4, 4, glu::PROFILE_CORE), GL_RGBA12, STR(GL_RGBA12), false, true, 12, 12, 12, 12, 0, 0, 1243 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1244 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA16, STR(GL_RGBA16), false, true, 16, 16, 16, 16, 0, 0, 1245 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1246 { glu::ContextType(3, 1, glu::PROFILE_CORE), GL_RGBA16_SNORM, STR(GL_RGBA16_SNORM), false, true, 16, 16, 16, 16, 0, 1247 0, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_SIGNED_NORMALIZED, GL_NONE }, 1248 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_SRGB8, STR(GL_SRGB8), true, true, 8, 8, 8, 0, 0, 0, 1249 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE, GL_NONE }, 1250 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_SRGB8_ALPHA8, STR(GL_SRGB8_ALPHA8), true, true, 8, 8, 8, 8, 0, 0, 1251 GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_UNSIGNED_NORMALIZED, GL_NONE }, 1252 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R16F, STR(GL_R16F), false, true, 16, 0, 0, 0, 0, 0, GL_FLOAT, 1253 GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1254 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG16F, STR(GL_RG16F), false, true, 16, 16, 0, 0, 0, 0, GL_FLOAT, 1255 GL_FLOAT, GL_NONE, GL_NONE, GL_NONE }, 1256 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB16F, STR(GL_RGB16F), false, true, 16, 16, 16, 0, 0, 0, GL_FLOAT, 1257 GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE }, 1258 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA16F, STR(GL_RGBA16F), false, true, 16, 16, 16, 16, 0, 0, 1259 GL_FLOAT, GL_FLOAT, GL_FLOAT, GL_FLOAT, GL_NONE }, 1260 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R32F, STR(GL_R32F), false, true, 32, 0, 0, 0, 0, 0, GL_FLOAT, 1261 GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1262 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG32F, STR(GL_RG32F), false, true, 32, 32, 0, 0, 0, 0, GL_FLOAT, 1263 GL_FLOAT, GL_NONE, GL_NONE, GL_NONE }, 1264 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB32F, STR(GL_RGB32F), false, true, 32, 32, 32, 0, 0, 0, GL_FLOAT, 1265 GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE }, 1266 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA32F, STR(GL_RGBA32F), false, true, 32, 32, 32, 32, 0, 0, 1267 GL_FLOAT, GL_FLOAT, GL_FLOAT, GL_FLOAT, GL_NONE }, 1268 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R11F_G11F_B10F, STR(GL_R11F_G11F_B10F), false, true, 11, 11, 10, 0, 1269 0, 0, GL_FLOAT, GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE }, 1270 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB9_E5, STR(GL_RGB9_E5), false, false, 9, 9, 9, 0, 0, 0, GL_FLOAT, 1271 GL_FLOAT, GL_FLOAT, GL_NONE, GL_NONE }, 1272 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R8I, STR(GL_R8I), false, true, 8, 0, 0, 0, 0, 0, GL_INT, GL_NONE, 1273 GL_NONE, GL_NONE, GL_NONE }, 1274 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R8UI, STR(GL_R8UI), false, true, 8, 0, 0, 0, 0, 0, GL_UNSIGNED_INT, 1275 GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1276 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R16I, STR(GL_R16I), false, true, 16, 0, 0, 0, 0, 0, GL_INT, GL_NONE, 1277 GL_NONE, GL_NONE, GL_NONE }, 1278 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R16UI, STR(GL_R16UI), false, true, 16, 0, 0, 0, 0, 0, 1279 GL_UNSIGNED_INT, GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1280 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R32I, STR(GL_R32I), false, true, 32, 0, 0, 0, 0, 0, GL_INT, GL_NONE, 1281 GL_NONE, GL_NONE, GL_NONE }, 1282 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_R32UI, STR(GL_R32UI), false, true, 32, 0, 0, 0, 0, 0, 1283 GL_UNSIGNED_INT, GL_NONE, GL_NONE, GL_NONE, GL_NONE }, 1284 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG8I, STR(GL_RG8I), false, true, 8, 8, 0, 0, 0, 0, GL_INT, GL_INT, 1285 GL_NONE, GL_NONE, GL_NONE }, 1286 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG8UI, STR(GL_RG8UI), false, true, 8, 8, 0, 0, 0, 0, 1287 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE, GL_NONE, GL_NONE }, 1288 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG16I, STR(GL_RG16I), false, true, 16, 16, 0, 0, 0, 0, GL_INT, 1289 GL_INT, GL_NONE, GL_NONE, GL_NONE }, 1290 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG16UI, STR(GL_RG16UI), false, true, 16, 16, 0, 0, 0, 0, 1291 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE, GL_NONE, GL_NONE }, 1292 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG32I, STR(GL_RG32I), false, true, 32, 32, 0, 0, 0, 0, GL_INT, 1293 GL_INT, GL_NONE, GL_NONE, GL_NONE }, 1294 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RG32UI, STR(GL_RG32UI), false, true, 32, 32, 0, 0, 0, 0, 1295 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE, GL_NONE, GL_NONE }, 1296 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB8I, STR(GL_RGB8I), false, true, 8, 8, 8, 0, 0, 0, GL_INT, GL_INT, 1297 GL_INT, GL_NONE, GL_NONE }, 1298 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB8UI, STR(GL_RGB8UI), false, true, 8, 8, 8, 0, 0, 0, 1299 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE, GL_NONE }, 1300 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB16I, STR(GL_RGB16I), false, true, 16, 16, 16, 0, 0, 0, GL_INT, 1301 GL_INT, GL_INT, GL_NONE, GL_NONE }, 1302 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB16UI, STR(GL_RGB16UI), false, true, 16, 16, 16, 0, 0, 0, 1303 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE, GL_NONE }, 1304 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB32I, STR(GL_RGB32I), false, true, 32, 32, 32, 0, 0, 0, GL_INT, 1305 GL_INT, GL_INT, GL_NONE, GL_NONE }, 1306 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGB32UI, STR(GL_RGB32UI), false, true, 32, 32, 32, 0, 0, 0, 1307 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE, GL_NONE }, 1308 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA8I, STR(GL_RGBA8I), false, true, 8, 8, 8, 8, 0, 0, GL_INT, 1309 GL_INT, GL_INT, GL_INT, GL_NONE }, 1310 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA8UI, STR(GL_RGBA8UI), false, true, 8, 8, 8, 8, 0, 0, 1311 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE }, 1312 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA16I, STR(GL_RGBA16I), false, true, 16, 16, 16, 16, 0, 0, GL_INT, 1313 GL_INT, GL_INT, GL_INT, GL_NONE }, 1314 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA16UI, STR(GL_RGBA16UI), false, true, 16, 16, 16, 16, 0, 0, 1315 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE }, 1316 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA32I, STR(GL_RGBA32I), false, true, 32, 32, 32, 32, 0, 0, GL_INT, 1317 GL_INT, GL_INT, GL_INT, GL_NONE }, 1318 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_RGBA32UI, STR(GL_RGBA32UI), false, true, 32, 32, 32, 32, 0, 0, 1319 GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_UNSIGNED_INT, GL_NONE }, 1320 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_DEPTH_COMPONENT16, STR(GL_DEPTH_COMPONENT16), false, true, 0, 0, 0, 1321 0, 16, 0, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_UNSIGNED_NORMALIZED }, 1322 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_DEPTH_COMPONENT24, STR(GL_DEPTH_COMPONENT24), false, true, 0, 0, 0, 1323 0, 24, 0, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_UNSIGNED_NORMALIZED }, 1324 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_DEPTH_COMPONENT32F, STR(GL_DEPTH_COMPONENT32F), false, true, 0, 0, 1325 0, 0, 32, 0, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_FLOAT }, 1326 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_DEPTH24_STENCIL8, STR(GL_DEPTH24_STENCIL8), false, true, 0, 0, 0, 0, 1327 24, 8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_UNSIGNED_NORMALIZED }, 1328 { glu::ContextType(3, 0, glu::PROFILE_CORE), GL_DEPTH32F_STENCIL8, STR(GL_DEPTH32F_STENCIL8), false, true, 0, 0, 0, 1329 0, 32, 8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_FLOAT } 1330 }; 1331 1332 const glw::GLuint FunctionalTest::s_formats_size = sizeof(s_formats) / sizeof(s_formats[0]); 1333 1334 const glw::GLchar* FunctionalTest::s_vertex_shader_code = "#version 150\n" 1335 "\n" 1336 "void main()\n" 1337 "{\n" 1338 " switch(gl_VertexID % 4)\n" 1339 " {\n" 1340 " case 0:\n" 1341 " gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n" 1342 " break;\n" 1343 " case 1:\n" 1344 " gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n" 1345 " break;\n" 1346 " case 2:\n" 1347 " gl_Position = vec4( 1.0, -1.0, 0.0, 1.0);\n" 1348 " break;\n" 1349 " case 3:\n" 1350 " gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n" 1351 " break;\n" 1352 " }\n" 1353 "}\n"; 1354 1355 const glw::GLchar* FunctionalTest::s_fragment_shader_template = 1356 "#version 150\n" 1357 "\n" 1358 "out TEMPLATE_TYPE result;\n" 1359 "\n" 1360 "uniform TEMPLATE_SAMPLER data;\n" 1361 "\n" 1362 "void main()\n" 1363 "{\n" 1364 " result = texelFetch(data, TEMPLATE_TEXEL_FETCH_ARGUMENTS)TEMPLATE_COMPONENT;\n" 1365 "}\n"; 1366 1367 /*===========================================================================================================*/ 1368 1369 namespace Utilities 1370 { 1371 1372 glw::GLuint buildProgram(glw::Functions const& gl, tcu::TestLog& log, glw::GLchar const* const vertex_shader_source, 1373 glw::GLchar const* const fragment_shader_source) 1374 { 1375 glw::GLuint program = 0; 1376 1377 struct Shader 1378 { 1379 glw::GLchar const* const source; 1380 glw::GLenum const type; 1381 glw::GLuint id; 1382 } shader[] = { { vertex_shader_source, GL_VERTEX_SHADER, 0 }, { fragment_shader_source, GL_FRAGMENT_SHADER, 0 } }; 1383 1384 glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]); 1385 1386 try 1387 { 1388 /* Create program. */ 1389 program = gl.createProgram(); 1390 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed."); 1391 1392 /* Shader compilation. */ 1393 1394 for (glw::GLuint i = 0; i < shader_count; ++i) 1395 { 1396 if (DE_NULL != shader[i].source) 1397 { 1398 shader[i].id = gl.createShader(shader[i].type); 1399 1400 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed."); 1401 1402 gl.attachShader(program, shader[i].id); 1403 1404 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader call failed."); 1405 1406 gl.shaderSource(shader[i].id, 1, &(shader[i].source), NULL); 1407 1408 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed."); 1409 1410 gl.compileShader(shader[i].id); 1411 1412 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed."); 1413 1414 glw::GLint status = GL_FALSE; 1415 1416 gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status); 1417 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed."); 1418 1419 if (GL_FALSE == status) 1420 { 1421 glw::GLint log_size = 0; 1422 gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size); 1423 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed."); 1424 1425 glw::GLchar* log_text = new glw::GLchar[log_size]; 1426 1427 gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]); 1428 1429 log << tcu::TestLog::Message << "Shader compilation has failed.\n" 1430 << "Shader type: " << glu::getShaderTypeStr(shader[i].type) << "\n" 1431 << "Shader compilation error log:\n" 1432 << log_text << "\n" 1433 << "Shader source code:\n" 1434 << shader[i].source << "\n" 1435 << tcu::TestLog::EndMessage; 1436 1437 delete[] log_text; 1438 1439 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog call failed."); 1440 1441 throw 0; 1442 } 1443 } 1444 } 1445 1446 /* Link. */ 1447 gl.linkProgram(program); 1448 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings call failed."); 1449 1450 glw::GLint status = GL_FALSE; 1451 1452 gl.getProgramiv(program, GL_LINK_STATUS, &status); 1453 1454 if (GL_TRUE == status) 1455 { 1456 for (glw::GLuint i = 0; i < shader_count; ++i) 1457 { 1458 if (shader[i].id) 1459 { 1460 gl.detachShader(program, shader[i].id); 1461 1462 GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed."); 1463 } 1464 } 1465 } 1466 else 1467 { 1468 glw::GLint log_size = 0; 1469 1470 gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &log_size); 1471 1472 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed."); 1473 1474 glw::GLchar* log_text = new glw::GLchar[log_size]; 1475 1476 gl.getProgramInfoLog(program, log_size, NULL, &log_text[0]); 1477 1478 log << tcu::TestLog::Message << "Program linkage has failed due to:\n" 1479 << log_text << "\n" 1480 << tcu::TestLog::EndMessage; 1481 1482 delete[] log_text; 1483 1484 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog call failed."); 1485 1486 throw 0; 1487 } 1488 } 1489 catch (...) 1490 { 1491 if (program) 1492 { 1493 gl.deleteProgram(program); 1494 1495 program = 0; 1496 } 1497 } 1498 1499 for (glw::GLuint i = 0; i < shader_count; ++i) 1500 { 1501 if (0 != shader[i].id) 1502 { 1503 gl.deleteShader(shader[i].id); 1504 1505 shader[i].id = 0; 1506 } 1507 } 1508 1509 return program; 1510 } 1511 1512 std::string preprocessString(std::string source, std::string key, std::string value) 1513 { 1514 std::string destination = source; 1515 1516 while (true) 1517 { 1518 /* Find token in source code. */ 1519 size_t position = destination.find(key, 0); 1520 1521 /* No more occurences of this key. */ 1522 if (position == std::string::npos) 1523 { 1524 break; 1525 } 1526 1527 /* Replace token with sub_code. */ 1528 destination.replace(position, key.size(), value); 1529 } 1530 1531 return destination; 1532 } 1533 1534 std::string itoa(glw::GLint i) 1535 { 1536 std::stringstream stream; 1537 1538 stream << i; 1539 1540 return stream.str(); 1541 } 1542 1543 } // namespace Utilities 1544 } // namespace TextureSizePromotion 1545 } // namespace gl3cts 1546
