es31fCopyImageTests.cpp revision 9ea37879e8c0ecc8a8973b3d5194d4dc12f21360
1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 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 Copy image tests for GL_EXT_copy_image. 22 *//*--------------------------------------------------------------------*/ 23 24#include "es31fCopyImageTests.hpp" 25 26#include "tes31TestCase.hpp" 27 28#include "glsTextureTestUtil.hpp" 29 30#include "gluContextInfo.hpp" 31#include "gluObjectWrapper.hpp" 32#include "gluRenderContext.hpp" 33#include "gluStrUtil.hpp" 34#include "gluTextureUtil.hpp" 35#include "gluPixelTransfer.hpp" 36 37#include "glwEnums.hpp" 38#include "glwFunctions.hpp" 39 40#include "tcuCompressedTexture.hpp" 41#include "tcuFloat.hpp" 42#include "tcuImageCompare.hpp" 43#include "tcuTestLog.hpp" 44#include "tcuTexture.hpp" 45#include "tcuTextureUtil.hpp" 46#include "tcuVector.hpp" 47#include "tcuVectorUtil.hpp" 48#include "tcuSeedBuilder.hpp" 49#include "tcuResultCollector.hpp" 50 51#include "deArrayBuffer.hpp" 52#include "deFloat16.h" 53#include "deRandom.hpp" 54#include "deStringUtil.hpp" 55#include "deUniquePtr.hpp" 56 57#include <map> 58#include <string> 59#include <vector> 60 61using namespace deqp::gls::TextureTestUtil; 62 63using tcu::Float; 64using tcu::IVec3; 65using tcu::Sampler; 66using tcu::ScopedLogSection; 67using tcu::TestLog; 68using tcu::Vec4; 69using tcu::SeedBuilder; 70 71using de::ArrayBuffer; 72 73using std::map; 74using std::string; 75using std::vector; 76using std::pair; 77 78namespace deqp 79{ 80namespace gles31 81{ 82namespace Functional 83{ 84namespace 85{ 86 87enum ViewClass 88{ 89 VIEWCLASS_128_BITS = 0, 90 VIEWCLASS_96_BITS, 91 VIEWCLASS_64_BITS, 92 VIEWCLASS_48_BITS, 93 VIEWCLASS_32_BITS, 94 VIEWCLASS_24_BITS, 95 VIEWCLASS_16_BITS, 96 VIEWCLASS_8_BITS, 97 98 VIEWCLASS_EAC_R11, 99 VIEWCLASS_EAC_RG11, 100 VIEWCLASS_ETC2_RGB, 101 VIEWCLASS_ETC2_RGBA, 102 VIEWCLASS_ETC2_EAC_RGBA, 103 VIEWCLASS_ASTC_4x4_RGBA, 104 VIEWCLASS_ASTC_5x4_RGBA, 105 VIEWCLASS_ASTC_5x5_RGBA, 106 VIEWCLASS_ASTC_6x5_RGBA, 107 VIEWCLASS_ASTC_6x6_RGBA, 108 VIEWCLASS_ASTC_8x5_RGBA, 109 VIEWCLASS_ASTC_8x6_RGBA, 110 VIEWCLASS_ASTC_8x8_RGBA, 111 VIEWCLASS_ASTC_10x5_RGBA, 112 VIEWCLASS_ASTC_10x6_RGBA, 113 VIEWCLASS_ASTC_10x8_RGBA, 114 VIEWCLASS_ASTC_10x10_RGBA, 115 VIEWCLASS_ASTC_12x10_RGBA, 116 VIEWCLASS_ASTC_12x12_RGBA 117}; 118 119const char* viewClassToName (ViewClass viewClass) 120{ 121 switch (viewClass) 122 { 123 case VIEWCLASS_128_BITS: return "viewclass_128_bits"; 124 case VIEWCLASS_96_BITS: return "viewclass_96_bits"; 125 case VIEWCLASS_64_BITS: return "viewclass_64_bits"; 126 case VIEWCLASS_48_BITS: return "viewclass_48_bits"; 127 case VIEWCLASS_32_BITS: return "viewclass_32_bits"; 128 case VIEWCLASS_24_BITS: return "viewclass_24_bits"; 129 case VIEWCLASS_16_BITS: return "viewclass_16_bits"; 130 case VIEWCLASS_8_BITS: return "viewclass_8_bits"; 131 case VIEWCLASS_EAC_R11: return "viewclass_eac_r11"; 132 case VIEWCLASS_EAC_RG11: return "viewclass_eac_rg11"; 133 case VIEWCLASS_ETC2_RGB: return "viewclass_etc2_rgb"; 134 case VIEWCLASS_ETC2_RGBA: return "viewclass_etc2_rgba"; 135 case VIEWCLASS_ETC2_EAC_RGBA: return "viewclass_etc2_eac_rgba"; 136 case VIEWCLASS_ASTC_4x4_RGBA: return "viewclass_astc_4x4_rgba"; 137 case VIEWCLASS_ASTC_5x4_RGBA: return "viewclass_astc_5x4_rgba"; 138 case VIEWCLASS_ASTC_5x5_RGBA: return "viewclass_astc_5x5_rgba"; 139 case VIEWCLASS_ASTC_6x5_RGBA: return "viewclass_astc_6x5_rgba"; 140 case VIEWCLASS_ASTC_6x6_RGBA: return "viewclass_astc_6x6_rgba"; 141 case VIEWCLASS_ASTC_8x5_RGBA: return "viewclass_astc_8x5_rgba"; 142 case VIEWCLASS_ASTC_8x6_RGBA: return "viewclass_astc_8x6_rgba"; 143 case VIEWCLASS_ASTC_8x8_RGBA: return "viewclass_astc_8x8_rgba"; 144 case VIEWCLASS_ASTC_10x5_RGBA: return "viewclass_astc_10x5_rgba"; 145 case VIEWCLASS_ASTC_10x6_RGBA: return "viewclass_astc_10x6_rgba"; 146 case VIEWCLASS_ASTC_10x8_RGBA: return "viewclass_astc_10x8_rgba"; 147 case VIEWCLASS_ASTC_10x10_RGBA: return "viewclass_astc_10x10_rgba"; 148 case VIEWCLASS_ASTC_12x10_RGBA: return "viewclass_astc_12x10_rgba"; 149 case VIEWCLASS_ASTC_12x12_RGBA: return "viewclass_astc_12x12_rgba"; 150 151 default: 152 DE_ASSERT(false); 153 return NULL; 154 } 155} 156 157const char* targetToName (deUint32 target) 158{ 159 switch (target) 160 { 161 case GL_RENDERBUFFER: return "renderbuffer"; 162 case GL_TEXTURE_2D: return "texture2d"; 163 case GL_TEXTURE_3D: return "texture3d"; 164 case GL_TEXTURE_2D_ARRAY: return "texture2d_array"; 165 case GL_TEXTURE_CUBE_MAP: return "cubemap"; 166 167 default: 168 DE_ASSERT(false); 169 return NULL; 170 } 171} 172 173string formatToName (deUint32 format) 174{ 175 string enumName; 176 177 if (glu::isCompressedFormat(format)) 178 enumName = glu::getCompressedTexFormatStr(format).toString().substr(14); // Strip GL_COMPRESSED_ 179 else 180 enumName = glu::getPixelFormatStr(format).toString().substr(3); // Strip GL_ 181 182 return de::toLower(enumName); 183} 184 185bool isFloatFormat (deUint32 format) 186{ 187 if (glu::isCompressedFormat(format)) 188 return false; 189 else 190 return tcu::getTextureChannelClass(glu::mapGLInternalFormat(format).type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT; 191} 192 193bool isUintFormat (deUint32 format) 194{ 195 if (glu::isCompressedFormat(format)) 196 return false; 197 else 198 return tcu::getTextureChannelClass(glu::mapGLInternalFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER; 199} 200 201bool isIntFormat (deUint32 format) 202{ 203 if (glu::isCompressedFormat(format)) 204 return false; 205 else 206 return tcu::getTextureChannelClass(glu::mapGLInternalFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER; 207} 208 209bool isTextureTarget (deUint32 target) 210{ 211 return target != GL_RENDERBUFFER; 212} 213 214int getTargetTexDims (deUint32 target) 215{ 216 DE_ASSERT(isTextureTarget(target)); 217 218 switch (target) 219 { 220 case GL_TEXTURE_1D: 221 return 1; 222 223 case GL_TEXTURE_1D_ARRAY: 224 case GL_TEXTURE_2D: 225 case GL_TEXTURE_CUBE_MAP: 226 return 2; 227 228 case GL_TEXTURE_2D_ARRAY: 229 case GL_TEXTURE_3D: 230 return 3; 231 232 default: 233 DE_ASSERT(false); 234 return -1; 235 } 236} 237 238class ImageInfo 239{ 240public: 241 ImageInfo (deUint32 format, deUint32 target, const IVec3& size); 242 243 deUint32 getFormat (void) const { return m_format; } 244 deUint32 getTarget (void) const { return m_target; } 245 const IVec3& getSize (void) const { return m_size; } 246 247private: 248 deUint32 m_format; 249 deUint32 m_target; 250 IVec3 m_size; 251}; 252 253ImageInfo::ImageInfo (deUint32 format, deUint32 target, const IVec3& size) 254 : m_format (format) 255 , m_target (target) 256 , m_size (size) 257{ 258 DE_ASSERT(m_target == GL_TEXTURE_2D_ARRAY || m_target == GL_TEXTURE_3D || m_size.z() == 1); 259 DE_ASSERT(isTextureTarget(m_target) || !glu::isCompressedFormat(m_target)); 260} 261 262 263SeedBuilder& operator<< (SeedBuilder& builder, const ImageInfo& info) 264{ 265 builder << info.getFormat() << info.getTarget() << info.getSize(); 266 return builder; 267} 268 269const glu::ObjectTraits& getObjectTraits (const ImageInfo& info) 270{ 271 if (isTextureTarget(info.getTarget())) 272 return glu::objectTraits(glu::OBJECTTYPE_TEXTURE); 273 else 274 return glu::objectTraits(glu::OBJECTTYPE_RENDERBUFFER); 275} 276 277int getLevelCount (const ImageInfo& info) 278{ 279 const deUint32 target = info.getTarget(); 280 const IVec3 size = info.getSize(); 281 282 if (target == GL_RENDERBUFFER) 283 return 1; 284 else if (target == GL_TEXTURE_2D_ARRAY) 285 { 286 const int maxSize = de::max(size.x(), size.y()); 287 288 return deLog2Ceil32(maxSize); 289 } 290 else 291 { 292 const int maxSize = de::max(size.x(), de::max(size.y(), size.z())); 293 294 return deLog2Ceil32(maxSize); 295 } 296} 297 298// Return format that has more restrictions on texel data. 299deUint32 getMoreRestrictiveFormat (deUint32 formatA, deUint32 formatB) 300{ 301 if (formatA == formatB) 302 return formatA; 303 else if (glu::isCompressedFormat(formatA) && isAstcFormat(glu::mapGLCompressedTexFormat(formatA))) 304 return formatA; 305 else if (glu::isCompressedFormat(formatB) && isAstcFormat(glu::mapGLCompressedTexFormat(formatB))) 306 return formatB; 307 else if (isFloatFormat(formatA)) 308 { 309 DE_ASSERT(!isFloatFormat(formatB)); 310 311 return formatA; 312 } 313 else if (isFloatFormat(formatB)) 314 { 315 DE_ASSERT(!isFloatFormat(formatA)); 316 317 return formatB; 318 } 319 else if (glu::isCompressedFormat(formatA)) 320 { 321 return formatA; 322 } 323 else if (glu::isCompressedFormat(formatB)) 324 { 325 return formatB; 326 } 327 else 328 return formatA; 329} 330 331int getTexelBlockSize (deUint32 format) 332{ 333 if (glu::isCompressedFormat(format)) 334 return tcu::getBlockSize(glu::mapGLCompressedTexFormat(format)); 335 else 336 return glu::mapGLInternalFormat(format).getPixelSize(); 337} 338 339IVec3 getTexelBlockPixelSize (deUint32 format) 340{ 341 if (glu::isCompressedFormat(format)) 342 return tcu::getBlockPixelSize(glu::mapGLCompressedTexFormat(format)); 343 else 344 return IVec3(1, 1, 1); 345} 346 347IVec3 getLevelSize (deUint32 target, const IVec3& baseSize, int level) 348{ 349 IVec3 size; 350 351 if (target != GL_TEXTURE_2D_ARRAY) 352 { 353 for (int i = 0; i < 3; i++) 354 size[i] = de::max(baseSize[i] >> level, 1); 355 } 356 else 357 { 358 for (int i = 0; i < 2; i++) 359 size[i] = de::max(baseSize[i] >> level, 1); 360 361 size[2] = baseSize[2]; 362 } 363 364 return size; 365} 366 367bool isColorRenderable (deUint32 format) 368{ 369 switch (format) 370 { 371 case GL_R8: 372 case GL_RG8: 373 case GL_RGB8: 374 case GL_RGB565: 375 case GL_RGB4: 376 case GL_RGB5_A1: 377 case GL_RGBA8: 378 case GL_RGB10_A2: 379 case GL_RGB10_A2UI: 380 case GL_SRGB8_ALPHA8: 381 case GL_R8I: 382 case GL_R8UI: 383 case GL_R16I: 384 case GL_R16UI: 385 case GL_R32I: 386 case GL_R32UI: 387 case GL_RG8I: 388 case GL_RG8UI: 389 case GL_RG16I: 390 case GL_RG16UI: 391 case GL_RG32I: 392 case GL_RG32UI: 393 case GL_RGBA8I: 394 case GL_RGBA8UI: 395 case GL_RGBA16I: 396 case GL_RGBA16UI: 397 case GL_RGBA32I: 398 case GL_RGBA32UI: 399 return true; 400 401 default: 402 return false; 403 } 404} 405 406deUint32 getTypeForInternalFormat (deUint32 format) 407{ 408 return glu::getTransferFormat(glu::mapGLInternalFormat(format)).dataType; 409} 410 411void genTexel (de::Random& rng, deUint32 glFormat, int texelBlockSize, const int texelCount, deUint8* buffer) 412{ 413 if (isFloatFormat(glFormat)) 414 { 415 const tcu::TextureFormat format = glu::mapGLInternalFormat(glFormat); 416 const tcu::PixelBufferAccess access (format, texelCount, 1, 1, buffer); 417 const tcu::TextureFormatInfo info = tcu::getTextureFormatInfo(format); 418 419 for (int texelNdx = 0; texelNdx < texelCount; texelNdx++) 420 { 421 const float red = rng.getFloat(info.valueMin.x(), info.valueMax.x()); 422 const float green = rng.getFloat(info.valueMin.y(), info.valueMax.y()); 423 const float blue = rng.getFloat(info.valueMin.z(), info.valueMax.z()); 424 const float alpha = rng.getFloat(info.valueMin.w(), info.valueMax.w()); 425 426 const Vec4 color (red, green, blue, alpha); 427 428 access.setPixel(color, texelNdx, 0, 0); 429 } 430 } 431 else if (glu::isCompressedFormat(glFormat)) 432 { 433 const tcu::CompressedTexFormat compressedFormat = glu::mapGLCompressedTexFormat(glFormat); 434 435 if (tcu::isAstcFormat(compressedFormat)) 436 { 437 const int BLOCK_SIZE = 16; 438 const deUint8 blocks[][BLOCK_SIZE] = 439 { 440 // \note All of the following blocks are valid in LDR mode. 441 { 252, 253, 255, 255, 255, 255, 255, 255, 8, 71, 90, 78, 22, 17, 26, 66, }, 442 { 252, 253, 255, 255, 255, 255, 255, 255, 220, 74, 139, 235, 249, 6, 145, 125 }, 443 { 252, 253, 255, 255, 255, 255, 255, 255, 223, 251, 28, 206, 54, 251, 160, 174 }, 444 { 252, 253, 255, 255, 255, 255, 255, 255, 39, 4, 153, 219, 180, 61, 51, 37 }, 445 { 67, 2, 0, 254, 1, 0, 64, 215, 83, 211, 159, 105, 41, 140, 50, 2 }, 446 { 67, 130, 0, 170, 84, 255, 65, 215, 83, 211, 159, 105, 41, 140, 50, 2 }, 447 { 67, 2, 129, 38, 51, 229, 95, 215, 83, 211, 159, 105, 41, 140, 50, 2 }, 448 { 67, 130, 193, 56, 213, 144, 95, 215, 83, 211, 159, 105, 41, 140, 50, 2 } 449 }; 450 451 DE_ASSERT(texelBlockSize == BLOCK_SIZE); 452 453 for (int i = 0; i < texelCount; i++) 454 { 455 const int blockNdx = rng.getInt(0, DE_LENGTH_OF_ARRAY(blocks)-1); 456 457 deMemcpy(buffer + i * BLOCK_SIZE, blocks[blockNdx], BLOCK_SIZE); 458 } 459 } 460 else 461 { 462 for (int i = 0; i < texelBlockSize * texelCount; i++) 463 { 464 const deUint8 val = rng.getUint8(); 465 466 buffer[i] = val; 467 } 468 } 469 } 470 else 471 { 472 for (int i = 0; i < texelBlockSize * texelCount; i++) 473 { 474 const deUint8 val = rng.getUint8(); 475 476 buffer[i] = val; 477 } 478 } 479} 480 481IVec3 divRoundUp (const IVec3& a, const IVec3& b) 482{ 483 IVec3 res; 484 485 for (int i =0; i < 3; i++) 486 res[i] = a[i] / b[i] + ((a[i] % b[i]) ? 1 : 0); 487 488 return res; 489} 490 491deUint32 mapFaceNdxToFace (int ndx) 492{ 493 const deUint32 cubeFaces[] = 494 { 495 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 496 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 497 498 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 499 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 500 501 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 502 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 503 }; 504 505 return de::getSizedArrayElement(cubeFaces, ndx); 506} 507 508deUint32 getFormatForInternalFormat (deUint32 format) 509{ 510 return glu::getTransferFormat(glu::mapGLInternalFormat(format)).format; 511} 512 513void genericTexImage (const glw::Functions& gl, 514 deUint32 target, 515 int faceNdx, 516 int level, 517 const IVec3& size, 518 deUint32 format, 519 size_t dataSize, 520 const void* data) 521{ 522 const deUint32 glTarget = (target == GL_TEXTURE_CUBE_MAP ? mapFaceNdxToFace(faceNdx) : target); 523 524 DE_ASSERT(target == GL_TEXTURE_CUBE_MAP || faceNdx == 0); 525 526 if (glu::isCompressedFormat(format)) 527 { 528 switch (getTargetTexDims(target)) 529 { 530 case 2: 531 DE_ASSERT(size.z() == 1); 532 gl.compressedTexImage2D(glTarget, level, format, (glw::GLsizei)size.x(), (glw::GLsizei)size.y(), 0, (glw::GLsizei)dataSize, data); 533 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage2D failed."); 534 break; 535 536 case 3: 537 gl.compressedTexImage3D(glTarget, level, format, (glw::GLsizei)size.x(), (glw::GLsizei)size.y(), (glw::GLsizei)size.z(), 0, (glw::GLsizei)dataSize, data); 538 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage3D failed."); 539 break; 540 541 default: 542 DE_ASSERT(false); 543 } 544 } 545 else 546 { 547 const deUint32 glFormat = getFormatForInternalFormat(format); 548 const deUint32 glType = getTypeForInternalFormat(format); 549 550 switch (getTargetTexDims(target)) 551 { 552 case 2: 553 DE_ASSERT(size.z() == 1); 554 gl.texImage2D(glTarget, level, format, (glw::GLsizei)size.x(), (glw::GLsizei)size.y(), 0, glFormat, glType, data); 555 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D failed."); 556 break; 557 558 case 3: 559 gl.texImage3D(glTarget, level, format, (glw::GLsizei)size.x(), (glw::GLsizei)size.y(), (glw::GLsizei)size.z(), 0, glFormat, glType, data); 560 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage3D failed."); 561 break; 562 563 default: 564 DE_ASSERT(false); 565 } 566 } 567} 568 569void genTextureImage (const glw::Functions& gl, 570 de::Random& rng, 571 deUint32 name, 572 vector<ArrayBuffer<deUint8> >& levels, 573 const ImageInfo& info, 574 deUint32 moreRestrictiveFormat) 575{ 576 const int texelBlockSize = getTexelBlockSize(info.getFormat()); 577 const IVec3 texelBlockPixelSize = getTexelBlockPixelSize(info.getFormat()); 578 const IVec3 size = info.getSize(); 579 580 levels.resize(getLevelCount(info)); 581 582 gl.pixelStorei(GL_UNPACK_ALIGNMENT, 1); 583 GLU_EXPECT_NO_ERROR(gl.getError(), "Setting pixel store aligment failed."); 584 585 gl.bindTexture(info.getTarget(), name); 586 GLU_EXPECT_NO_ERROR(gl.getError(), "Binding texture failed."); 587 588 for (int levelNdx = 0; levelNdx < getLevelCount(info); levelNdx++) 589 { 590 ArrayBuffer<deUint8>& level = levels[levelNdx]; 591 592 const int faceCount = (info.getTarget() == GL_TEXTURE_CUBE_MAP ? 6 : 1); 593 594 const IVec3 levelPixelSize = getLevelSize(info.getTarget(), info.getSize(), levelNdx); 595 const IVec3 levelTexelBlockSize = divRoundUp(levelPixelSize, texelBlockPixelSize); 596 const int levelTexelBlockCount = levelTexelBlockSize.x() * levelTexelBlockSize.y() * levelTexelBlockSize.z(); 597 const int levelSize = levelTexelBlockCount * texelBlockSize; 598 599 level.setStorage(levelSize * faceCount); 600 601 for (int faceNdx = 0; faceNdx < faceCount; faceNdx++) 602 { 603 genTexel(rng, moreRestrictiveFormat, texelBlockSize, levelTexelBlockCount, level.getElementPtr(faceNdx * levelSize)); 604 605 genericTexImage(gl, info.getTarget(), faceNdx, levelNdx, levelPixelSize, info.getFormat(), levelSize, level.getElementPtr(faceNdx * levelSize)); 606 } 607 } 608 609 gl.texParameteri(info.getTarget(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 610 gl.texParameteri(info.getTarget(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 611 612 if (info.getTarget() == GL_TEXTURE_3D) 613 gl.texParameteri(info.getTarget(), GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 614 615 gl.texParameteri(info.getTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST); 616 gl.texParameteri(info.getTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST); 617 GLU_EXPECT_NO_ERROR(gl.getError(), "Setting texture parameters failed"); 618 619 gl.bindTexture(info.getTarget(), 0); 620 GLU_EXPECT_NO_ERROR(gl.getError(), "Unbinding texture failed."); 621} 622 623void genRenderbufferImage (const glw::Functions& gl, 624 de::Random& rng, 625 deUint32 name, 626 vector<ArrayBuffer<deUint8> >& levels, 627 const ImageInfo& info, 628 deUint32 moreRestrictiveFormat) 629{ 630 const IVec3 size = info.getSize(); 631 const tcu::TextureFormat format = glu::mapGLInternalFormat(info.getFormat()); 632 633 DE_ASSERT(info.getTarget() == GL_RENDERBUFFER); 634 DE_ASSERT(info.getSize().z() == 1); 635 DE_ASSERT(getLevelCount(info) == 1); 636 DE_ASSERT(!glu::isCompressedFormat(info.getFormat())); 637 638 glu::Framebuffer framebuffer(gl); 639 640 levels.resize(1); 641 levels[0].setStorage(format.getPixelSize() * size.x() * size.y()); 642 tcu::PixelBufferAccess refAccess(format, size.x(), size.y(), 1, levels[0].getPtr()); 643 644 gl.bindRenderbuffer(GL_RENDERBUFFER, name); 645 gl.renderbufferStorage(GL_RENDERBUFFER, info.getFormat(), info.getSize().x(), info.getSize().y()); 646 GLU_EXPECT_NO_ERROR(gl.getError(), "Binding and setting storage for renderbuffer failed."); 647 648 gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer); 649 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, name); 650 GLU_EXPECT_NO_ERROR(gl.getError(), "Binding framebuffer and attaching renderbuffer failed."); 651 652 { 653 vector<deUint8> texelBlock(format.getPixelSize()); 654 655 genTexel(rng, moreRestrictiveFormat, format.getPixelSize(), 1, &(texelBlock[0])); 656 657 { 658 const tcu::ConstPixelBufferAccess texelAccess (format, 1, 1, 1, &(texelBlock[0])); 659 660 if (isFloatFormat(info.getFormat())) 661 { 662 const tcu::Vec4 color = texelAccess.getPixel(0, 0, 0); 663 664 gl.clearBufferfv(GL_COLOR, 0, (const float*)&color); 665 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to clear renderbuffer."); 666 667 tcu::clear(refAccess, color); 668 } 669 else if (isIntFormat(info.getFormat())) 670 { 671 const tcu::IVec4 color = texelAccess.getPixelInt(0, 0, 0); 672 673 gl.clearBufferiv(GL_COLOR, 0, (const deInt32*)&color); 674 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to clear renderbuffer."); 675 676 tcu::clear(refAccess, color); 677 } 678 else if (isUintFormat(info.getFormat())) 679 { 680 const tcu::IVec4 color = texelAccess.getPixelInt(0, 0, 0); 681 682 gl.clearBufferuiv(GL_COLOR, 0, (const deUint32*)&color); 683 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to clear renderbuffer."); 684 685 tcu::clear(refAccess, color); 686 } 687 else 688 { 689 const tcu::Vec4 color = texelAccess.getPixel(0, 0, 0); 690 691 gl.clearColor(color.x(), color.y(), color.z(), color.w()); 692 gl.clear(GL_COLOR_BUFFER_BIT); 693 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to clear renderbuffer."); 694 695 tcu::clear(refAccess, color); 696 } 697 } 698 } 699 700 gl.bindRenderbuffer(GL_RENDERBUFFER, 0); 701 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 702 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unbind renderbufer and framebuffer."); 703} 704 705 706 707void genImage (const glw::Functions& gl, 708 de::Random& rng, 709 deUint32 name, 710 vector<ArrayBuffer<deUint8> >& levels, 711 const ImageInfo& info, 712 deUint32 moreRestrictiveFormat) 713{ 714 if (isTextureTarget(info.getTarget())) 715 genTextureImage(gl, rng, name, levels, info, moreRestrictiveFormat); 716 else 717 genRenderbufferImage(gl, rng, name, levels, info, moreRestrictiveFormat); 718} 719 720IVec3 getTexelBlockStride (const ImageInfo& info, int level) 721{ 722 const IVec3 size = getLevelSize(info.getTarget(), info.getSize(), level); 723 const int texelBlockSize = getTexelBlockSize(info.getFormat()); 724 const IVec3 texelBlockPixelSize = getTexelBlockPixelSize(info.getFormat()); 725 const IVec3 textureTexelBlockSize = divRoundUp(size, texelBlockPixelSize); 726 727 return IVec3(texelBlockSize, textureTexelBlockSize.x() * texelBlockSize, textureTexelBlockSize.x() * textureTexelBlockSize.y() * texelBlockSize); 728} 729 730int sumComponents (const IVec3& v) 731{ 732 int s = 0; 733 734 for (int i = 0; i < 3; i++) 735 s += v[i]; 736 737 return s; 738} 739 740void copyImageData (vector<ArrayBuffer<deUint8> >& dstImageData, 741 const ImageInfo& dstImageInfo, 742 int dstLevel, 743 const IVec3& dstPos, 744 745 const vector<ArrayBuffer<deUint8> >& srcImageData, 746 const ImageInfo& srcImageInfo, 747 int srcLevel, 748 const IVec3& srcPos, 749 750 const IVec3& copySize) 751{ 752 const ArrayBuffer<deUint8>& srcLevelData = srcImageData[srcLevel]; 753 ArrayBuffer<deUint8>& dstLevelData = dstImageData[dstLevel]; 754 755 const IVec3 srcTexelBlockPixelSize = getTexelBlockPixelSize(srcImageInfo.getFormat()); 756 const int srcTexelBlockSize = getTexelBlockSize(srcImageInfo.getFormat()); 757 const IVec3 srcTexelPos = srcPos / srcTexelBlockPixelSize; 758 const IVec3 srcTexelBlockStride = getTexelBlockStride(srcImageInfo, srcLevel); 759 760 const IVec3 dstTexelBlockPixelSize = getTexelBlockPixelSize(dstImageInfo.getFormat()); 761 const int dstTexelBlockSize = getTexelBlockSize(dstImageInfo.getFormat()); 762 const IVec3 dstTexelPos = dstPos / dstTexelBlockPixelSize; 763 const IVec3 dstTexelBlockStride = getTexelBlockStride(dstImageInfo, dstLevel); 764 765 const IVec3 copyTexelBlockCount = copySize / srcTexelBlockPixelSize; 766 const int texelBlockSize = srcTexelBlockSize; 767 768 DE_ASSERT(srcTexelBlockSize == dstTexelBlockSize); 769 DE_UNREF(dstTexelBlockSize); 770 771 DE_ASSERT((copySize.x() % srcTexelBlockPixelSize.x()) == 0); 772 DE_ASSERT((copySize.y() % srcTexelBlockPixelSize.y()) == 0); 773 DE_ASSERT((copySize.z() % srcTexelBlockPixelSize.z()) == 0); 774 775 DE_ASSERT((srcPos.x() % srcTexelBlockPixelSize.x()) == 0); 776 DE_ASSERT((srcPos.y() % srcTexelBlockPixelSize.y()) == 0); 777 DE_ASSERT((srcPos.z() % srcTexelBlockPixelSize.z()) == 0); 778 779 for (int z = 0; z < copyTexelBlockCount.z(); z++) 780 for (int y = 0; y < copyTexelBlockCount.y(); y++) 781 { 782 const IVec3 blockPos (0, y, z); 783 const deUint8* const srcPtr = srcLevelData.getElementPtr(sumComponents((srcTexelPos + blockPos) * srcTexelBlockStride)); 784 deUint8* const dstPtr = dstLevelData.getElementPtr(sumComponents((dstTexelPos + blockPos) * dstTexelBlockStride)); 785 const int copyLineSize = copyTexelBlockCount.x() * texelBlockSize; 786 787 deMemcpy(dstPtr, srcPtr, copyLineSize); 788 } 789} 790 791vector<tcu::ConstPixelBufferAccess> getLevelAccesses (const vector<ArrayBuffer<deUint8> >& data, const ImageInfo& info) 792{ 793 const tcu::TextureFormat format = glu::mapGLInternalFormat(info.getFormat()); 794 const IVec3 size = info.getSize(); 795 796 vector<tcu::ConstPixelBufferAccess> result; 797 798 DE_ASSERT((int)data.size() == getLevelCount(info)); 799 800 for (int level = 0; level < (int)data.size(); level++) 801 { 802 const IVec3 levelSize = getLevelSize(info.getTarget(), size, level); 803 804 result.push_back(tcu::ConstPixelBufferAccess(format, levelSize.x(), levelSize.y(), levelSize.z(), data[level].getPtr())); 805 } 806 807 return result; 808} 809 810vector<tcu::ConstPixelBufferAccess> getCubeLevelAccesses (const vector<ArrayBuffer<deUint8> >& data, 811 const ImageInfo& info, 812 int faceNdx) 813{ 814 const tcu::TextureFormat format = glu::mapGLInternalFormat(info.getFormat()); 815 const IVec3 size = info.getSize(); 816 const int texelBlockSize = getTexelBlockSize(info.getFormat()); 817 const IVec3 texelBlockPixelSize = getTexelBlockPixelSize(info.getFormat()); 818 vector<tcu::ConstPixelBufferAccess> result; 819 820 DE_ASSERT(info.getTarget() == GL_TEXTURE_CUBE_MAP); 821 DE_ASSERT((int)data.size() == getLevelCount(info)); 822 823 for (int level = 0; level < (int)data.size(); level++) 824 { 825 const IVec3 levelPixelSize = getLevelSize(info.getTarget(), size, level); 826 const IVec3 levelTexelBlockSize = divRoundUp(levelPixelSize, texelBlockPixelSize); 827 const int levelTexelBlockCount = levelTexelBlockSize.x() * levelTexelBlockSize.y() * levelTexelBlockSize.z(); 828 const int levelSize = levelTexelBlockCount * texelBlockSize; 829 830 result.push_back(tcu::ConstPixelBufferAccess(format, levelPixelSize.x(), levelPixelSize.y(), levelPixelSize.z(), data[level].getElementPtr(levelSize * faceNdx))); 831 } 832 833 return result; 834} 835 836void copyImage (const glw::Functions& gl, 837 838 deUint32 dstName, 839 vector<ArrayBuffer<deUint8> >& dstImageData, 840 const ImageInfo& dstImageInfo, 841 int dstLevel, 842 const IVec3& dstPos, 843 844 deUint32 srcName, 845 const vector<ArrayBuffer<deUint8> >& srcImageData, 846 const ImageInfo& srcImageInfo, 847 int srcLevel, 848 const IVec3& srcPos, 849 850 const IVec3& copySize) 851{ 852 gl.copyImageSubData(srcName, srcImageInfo.getTarget(), srcLevel, srcPos.x(), srcPos.y(), srcPos.z(), 853 dstName, dstImageInfo.getTarget(), dstLevel, dstPos.x(), dstPos.y(), dstPos.z(), 854 copySize.x(), copySize.y(), copySize.z()); 855 856 GLU_EXPECT_NO_ERROR(gl.getError(), "glCopyImageSubData failed."); 857 858 copyImageData(dstImageData, dstImageInfo, dstLevel, dstPos, 859 srcImageData, srcImageInfo, srcLevel, srcPos, copySize); 860} 861 862void verifyTexture2DView (tcu::TestContext& testContext, 863 glu::RenderContext& renderContext, 864 TextureRenderer& renderer, 865 tcu::ResultCollector& results, 866 de::Random& rng, 867 deUint32 name, 868 const ImageInfo& info, 869 const tcu::Texture2DView& refTexture) 870{ 871 tcu::TestLog& log = testContext.getLog(); 872 const glw::Functions& gl = renderContext.getFunctions(); 873 const tcu::RGBA threshold = renderContext.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 874 const tcu::TextureFormat format = refTexture.getLevel(0).getFormat(); 875 const tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(format); 876 877 ReferenceParams renderParams (TEXTURETYPE_2D); 878 879 renderParams.samplerType = getSamplerType(format); 880 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST_MIPMAP_NEAREST, Sampler::NEAREST); 881 renderParams.colorScale = spec.lookupScale; 882 renderParams.colorBias = spec.lookupBias; 883 884 gl.activeTexture(GL_TEXTURE0); 885 gl.bindTexture(GL_TEXTURE_2D, name); 886 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind texture."); 887 888 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 889 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 890 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 891 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 892 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup texture filtering state."); 893 894 for (int level = 0; level < getLevelCount(info); level++) 895 { 896 const IVec3 levelSize = getLevelSize(info.getTarget(), info.getSize(), level); 897 const RandomViewport viewport (renderContext.getRenderTarget(), levelSize.x(), levelSize.y(), rng.getUint32()); 898 899 vector<float> texCoord; 900 tcu::Surface renderedFrame (viewport.width, viewport.height); 901 tcu::Surface referenceFrame (viewport.width, viewport.height); 902 903 computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 904 905 // Setup base viewport. 906 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 907 908 // Draw. 909 renderer.renderQuad(0, &texCoord[0], renderParams); 910 glu::readPixels(renderContext, viewport.x, viewport.y, renderedFrame.getAccess()); 911 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render and read pixels."); 912 913 // Compute reference. 914 sampleTexture(SurfaceAccess(referenceFrame, renderContext.getRenderTarget().getPixelFormat()), refTexture, &texCoord[0], renderParams); 915 916 // Compare and log. 917 if (!pixelThresholdCompare(log, ("Level" + de::toString(level)).c_str(), ("Render level " + de::toString(level)).c_str(), referenceFrame, renderedFrame, threshold, tcu::COMPARE_LOG_ON_ERROR)) 918 results.fail("Image comparison of level " + de::toString(level) + " failed."); 919 else 920 log << TestLog::Message << "Image comparison of level " << level << " passed." << TestLog::EndMessage; 921 } 922 923 gl.bindTexture(GL_TEXTURE_2D, 0); 924 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unbind texture."); 925} 926 927void decompressTextureLevel (const tcu::TexDecompressionParams& params, 928 ArrayBuffer<deUint8>& levelData, 929 tcu::PixelBufferAccess& levelAccess, 930 const tcu::CompressedTexFormat& compressedFormat, 931 const tcu::TextureFormat& decompressedFormat, 932 const IVec3& levelPixelSize, 933 const void* data) 934{ 935 levelData.setStorage(levelPixelSize.x() * levelPixelSize.y() * levelPixelSize.z() * decompressedFormat.getPixelSize()); 936 levelAccess = tcu::PixelBufferAccess(decompressedFormat, levelPixelSize.x(), levelPixelSize.y(), levelPixelSize.z(), levelData.getPtr()); 937 938 tcu::decompress(levelAccess, compressedFormat, (const deUint8*)data, params); 939} 940 941void decompressTexture (vector<ArrayBuffer<deUint8> >& levelDatas, 942 vector<tcu::PixelBufferAccess>& levelAccesses, 943 glu::RenderContext& renderContext, 944 const ImageInfo& info, 945 const vector<ArrayBuffer<deUint8> >& data) 946{ 947 const tcu::CompressedTexFormat compressedFormat = glu::mapGLCompressedTexFormat(info.getFormat()); 948 const tcu::TextureFormat decompressedFormat = tcu::getUncompressedFormat(compressedFormat); 949 const IVec3 size = info.getSize(); 950 de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(renderContext)); 951 tcu::TexDecompressionParams decompressParams; 952 953 if (tcu::isAstcFormat(compressedFormat)) 954 { 955 if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_hdr")) 956 decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_HDR); 957 else if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_ldr")) 958 decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR); 959 else 960 DE_ASSERT(false); 961 } 962 963 levelDatas.resize(getLevelCount(info)); 964 levelAccesses.resize(getLevelCount(info)); 965 966 for (int level = 0; level < getLevelCount(info); level++) 967 { 968 const IVec3 levelPixelSize = getLevelSize(info.getTarget(), size, level); 969 de::ArrayBuffer<deUint8>& levelData = levelDatas[level]; 970 tcu::PixelBufferAccess& levelAccess = levelAccesses[level]; 971 972 decompressTextureLevel(decompressParams, levelData, levelAccess, compressedFormat, decompressedFormat, levelPixelSize, data[level].getPtr()); 973 } 974} 975 976void verifyTexture2D (tcu::TestContext& testContext, 977 glu::RenderContext& renderContext, 978 TextureRenderer& textureRenderer, 979 tcu::ResultCollector& results, 980 de::Random& rng, 981 deUint32 name, 982 const vector<ArrayBuffer<deUint8> >& data, 983 const ImageInfo& info) 984{ 985 if (glu::isCompressedFormat(info.getFormat())) 986 { 987 vector<de::ArrayBuffer<deUint8> > levelDatas; 988 vector<tcu::PixelBufferAccess> levelAccesses; 989 990 decompressTexture(levelDatas, levelAccesses, renderContext, info, data); 991 992 { 993 const tcu::Texture2DView refTexture((int)levelAccesses.size(), &(levelAccesses[0])); 994 995 verifyTexture2DView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 996 } 997 } 998 else 999 { 1000 const vector<tcu::ConstPixelBufferAccess> levelAccesses = getLevelAccesses(data, info); 1001 const tcu::Texture2DView refTexture ((int)levelAccesses.size(), &(levelAccesses[0])); 1002 1003 verifyTexture2DView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1004 } 1005} 1006 1007void verifyTexture3DView (tcu::TestContext& testContext, 1008 glu::RenderContext& renderContext, 1009 TextureRenderer& renderer, 1010 tcu::ResultCollector& results, 1011 de::Random& rng, 1012 deUint32 name, 1013 const ImageInfo& info, 1014 const tcu::Texture3DView& refTexture) 1015{ 1016 tcu::TestLog& log = testContext.getLog(); 1017 const glw::Functions& gl = renderContext.getFunctions(); 1018 const tcu::RGBA threshold = renderContext.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 1019 const tcu::TextureFormat format = refTexture.getLevel(0).getFormat(); 1020 const tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(format); 1021 1022 ReferenceParams renderParams (TEXTURETYPE_3D); 1023 1024 renderParams.samplerType = getSamplerType(format); 1025 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST_MIPMAP_NEAREST, Sampler::NEAREST); 1026 renderParams.colorScale = spec.lookupScale; 1027 renderParams.colorBias = spec.lookupBias; 1028 1029 gl.activeTexture(GL_TEXTURE0); 1030 gl.bindTexture(GL_TEXTURE_3D, name); 1031 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind texture."); 1032 1033 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1034 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1035 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 1036 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 1037 gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1038 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup texture filtering state."); 1039 1040 for (int level = 0; level < getLevelCount(info); level++) 1041 { 1042 const IVec3 levelSize = getLevelSize(info.getTarget(), info.getSize(), level); 1043 1044 for (int slice = 0; slice < levelSize.z(); slice++) 1045 { 1046 const RandomViewport viewport (renderContext.getRenderTarget(), levelSize.x(), levelSize.y(), rng.getUint32()); 1047 const float r = (float(slice) + 0.5f) / levelSize.z(); 1048 tcu::Surface renderedFrame (viewport.width, viewport.height); 1049 tcu::Surface referenceFrame (viewport.width, viewport.height); 1050 vector<float> texCoord; 1051 1052 computeQuadTexCoord3D(texCoord, tcu::Vec3(0.0f, 0.0f, r), tcu::Vec3(1.0f, 1.0f, r), tcu::IVec3(0, 1, 2)); 1053 1054 // Setup base viewport. 1055 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 1056 1057 // Draw. 1058 renderer.renderQuad(0, &texCoord[0], renderParams); 1059 glu::readPixels(renderContext, viewport.x, viewport.y, renderedFrame.getAccess()); 1060 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render and read pixels."); 1061 1062 // Compute reference. 1063 sampleTexture(SurfaceAccess(referenceFrame, renderContext.getRenderTarget().getPixelFormat()), refTexture, &texCoord[0], renderParams); 1064 1065 // Compare and log. 1066 if (!pixelThresholdCompare(log, ("Level" + de::toString(level) + "Slice" + de::toString(slice)).c_str(), ("Render level " + de::toString(level) + ", Slice" + de::toString(slice)).c_str(), referenceFrame, renderedFrame, threshold, tcu::COMPARE_LOG_ON_ERROR)) 1067 results.fail("Image comparison of level " + de::toString(level) + " and slice " + de::toString(slice) + " failed."); 1068 else 1069 log << TestLog::Message << "Image comparison of level " << level << " and slice " << slice << " passed." << TestLog::EndMessage;; 1070 } 1071 } 1072 1073 gl.bindTexture(GL_TEXTURE_3D, 0); 1074 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unbind texture."); 1075} 1076 1077void verifyTexture3D (tcu::TestContext& testContext, 1078 glu::RenderContext& renderContext, 1079 TextureRenderer& textureRenderer, 1080 tcu::ResultCollector& results, 1081 de::Random& rng, 1082 deUint32 name, 1083 const vector<ArrayBuffer<deUint8> >& data, 1084 const ImageInfo& info) 1085{ 1086 if (glu::isCompressedFormat(info.getFormat())) 1087 { 1088 vector<de::ArrayBuffer<deUint8> > levelDatas; 1089 vector<tcu::PixelBufferAccess> levelAccesses; 1090 1091 decompressTexture(levelDatas, levelAccesses, renderContext, info, data); 1092 1093 { 1094 const tcu::Texture3DView refTexture((int)levelAccesses.size(), &(levelAccesses[0])); 1095 1096 verifyTexture3DView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1097 } 1098 } 1099 else 1100 { 1101 const vector<tcu::ConstPixelBufferAccess> levelAccesses = getLevelAccesses(data, info); 1102 const tcu::Texture3DView refTexture ((int)levelAccesses.size(), &(levelAccesses[0])); 1103 1104 verifyTexture3DView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1105 } 1106} 1107 1108void verifyTextureCubemapView (tcu::TestContext& testContext, 1109 glu::RenderContext& renderContext, 1110 TextureRenderer& renderer, 1111 tcu::ResultCollector& results, 1112 de::Random& rng, 1113 deUint32 name, 1114 const ImageInfo& info, 1115 const tcu::TextureCubeView& refTexture) 1116{ 1117 tcu::TestLog& log = testContext.getLog(); 1118 const glw::Functions& gl = renderContext.getFunctions(); 1119 const tcu::RGBA threshold = renderContext.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 1120 const tcu::TextureFormat format = refTexture.getLevelFace(0, tcu::CUBEFACE_POSITIVE_X).getFormat(); 1121 const tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(format); 1122 1123 ReferenceParams renderParams (TEXTURETYPE_CUBE); 1124 1125 renderParams.samplerType = getSamplerType(format); 1126 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST_MIPMAP_NEAREST, Sampler::NEAREST); 1127 renderParams.colorScale = spec.lookupScale; 1128 renderParams.colorBias = spec.lookupBias; 1129 1130 gl.activeTexture(GL_TEXTURE0); 1131 gl.bindTexture(GL_TEXTURE_CUBE_MAP, name); 1132 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind texture."); 1133 1134 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1135 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1136 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 1137 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1138 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup texture filtering state."); 1139 1140 for (int level = 0; level < getLevelCount(info); level++) 1141 { 1142 const IVec3 levelSize = getLevelSize(info.getTarget(), info.getSize(), level); 1143 1144 // \note It seems we can't reliably sample two smallest texture levels with cubemaps 1145 if (levelSize.x() < 4 && levelSize.y() < 4) 1146 continue; 1147 1148 for (int face = 0; face < 6; face++) 1149 { 1150 const RandomViewport viewport (renderContext.getRenderTarget(), levelSize.x(), levelSize.y(), rng.getUint32()); 1151 const string cubemapFaceName = glu::getCubeMapFaceStr(mapFaceNdxToFace(face)).toString(); 1152 tcu::Surface renderedFrame (viewport.width, viewport.height); 1153 tcu::Surface referenceFrame (viewport.width, viewport.height); 1154 vector<float> texCoord; 1155 1156 computeQuadTexCoordCube(texCoord, glu::getCubeFaceFromGL(mapFaceNdxToFace(face))); 1157 1158 // Setup base viewport. 1159 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 1160 1161 // Draw. 1162 renderer.renderQuad(0, &texCoord[0], renderParams); 1163 glu::readPixels(renderContext, viewport.x, viewport.y, renderedFrame.getAccess()); 1164 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render and read pixels."); 1165 1166 // Compute reference. 1167 sampleTexture(SurfaceAccess(referenceFrame, renderContext.getRenderTarget().getPixelFormat()), refTexture, &texCoord[0], renderParams); 1168 1169 // Compare and log. 1170 if (!pixelThresholdCompare(log, ("Level" + de::toString(level) + "Face" + cubemapFaceName).c_str(), ("Render level " + de::toString(level) + ", Face " + cubemapFaceName).c_str(), referenceFrame, renderedFrame, threshold, tcu::COMPARE_LOG_ON_ERROR)) 1171 results.fail("Image comparison of level " + de::toString(level) + " and face " + cubemapFaceName + " failed."); 1172 else 1173 log << TestLog::Message << "Image comparison of level " << level << " and face " << cubemapFaceName << " passed." << TestLog::EndMessage; 1174 } 1175 } 1176 1177 gl.bindTexture(GL_TEXTURE_CUBE_MAP, 0); 1178 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unbind texture."); 1179} 1180 1181void verifyTextureCubemap (tcu::TestContext& testContext, 1182 glu::RenderContext& renderContext, 1183 TextureRenderer& textureRenderer, 1184 tcu::ResultCollector& results, 1185 de::Random& rng, 1186 deUint32 name, 1187 const vector<ArrayBuffer<deUint8> >& data, 1188 const ImageInfo& info) 1189{ 1190 if (glu::isCompressedFormat(info.getFormat())) 1191 { 1192 const tcu::CompressedTexFormat& compressedFormat = glu::mapGLCompressedTexFormat(info.getFormat()); 1193 const tcu::TextureFormat& decompressedFormat = tcu::getUncompressedFormat(compressedFormat); 1194 1195 const int texelBlockSize = getTexelBlockSize(info.getFormat()); 1196 const IVec3 texelBlockPixelSize = getTexelBlockPixelSize(info.getFormat()); 1197 1198 vector<tcu::PixelBufferAccess> levelAccesses[6]; 1199 vector<ArrayBuffer<deUint8> > levelDatas[6]; 1200 de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(renderContext)); 1201 tcu::TexDecompressionParams decompressParams; 1202 1203 if (tcu::isAstcFormat(compressedFormat)) 1204 { 1205 if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_hdr")) 1206 decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_HDR); 1207 else if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_ldr")) 1208 decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR); 1209 else 1210 DE_ASSERT(false); 1211 } 1212 1213 for (int faceNdx = 0; faceNdx < 6; faceNdx++) 1214 { 1215 levelAccesses[faceNdx].resize(getLevelCount(info)); 1216 levelDatas[faceNdx].resize(getLevelCount(info)); 1217 } 1218 1219 for (int level = 0; level < getLevelCount(info); level++) 1220 { 1221 for (int faceNdx = 0; faceNdx < 6; faceNdx++) 1222 { 1223 const IVec3 levelPixelSize = getLevelSize(info.getTarget(), info.getSize(), level); 1224 const IVec3 levelTexelBlockSize = divRoundUp(levelPixelSize, texelBlockPixelSize); 1225 const int levelTexelBlockCount = levelTexelBlockSize.x() * levelTexelBlockSize.y() * levelTexelBlockSize.z(); 1226 const int levelSize = levelTexelBlockCount * texelBlockSize; 1227 1228 const deUint8* dataPtr = data[level].getElementPtr(faceNdx * levelSize); 1229 tcu::PixelBufferAccess& levelAccess = levelAccesses[faceNdx][level]; 1230 ArrayBuffer<deUint8>& levelData = levelDatas[faceNdx][level]; 1231 1232 decompressTextureLevel(decompressParams, levelData, levelAccess, compressedFormat, decompressedFormat, levelPixelSize, dataPtr); 1233 } 1234 } 1235 1236 const tcu::ConstPixelBufferAccess* levels[6]; 1237 1238 for (int faceNdx = 0; faceNdx < 6; faceNdx++) 1239 levels[glu::getCubeFaceFromGL(mapFaceNdxToFace(faceNdx))] = &(levelAccesses[faceNdx][0]); 1240 1241 { 1242 const tcu::TextureCubeView refTexture(getLevelCount(info), levels); 1243 1244 verifyTextureCubemapView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1245 } 1246 } 1247 else 1248 { 1249 const vector<tcu::ConstPixelBufferAccess> levelAccesses[6] = 1250 { 1251 getCubeLevelAccesses(data, info, 0), 1252 getCubeLevelAccesses(data, info, 1), 1253 getCubeLevelAccesses(data, info, 2), 1254 getCubeLevelAccesses(data, info, 3), 1255 getCubeLevelAccesses(data, info, 4), 1256 getCubeLevelAccesses(data, info, 5), 1257 }; 1258 1259 const tcu::ConstPixelBufferAccess* levels[6]; 1260 1261 for (int faceNdx = 0; faceNdx < 6; faceNdx++) 1262 levels[glu::getCubeFaceFromGL(mapFaceNdxToFace(faceNdx))] = &(levelAccesses[faceNdx][0]); 1263 1264 { 1265 const tcu::TextureCubeView refTexture(getLevelCount(info), levels); 1266 1267 verifyTextureCubemapView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1268 } 1269 } 1270} 1271 1272void verifyTexture2DArrayView (tcu::TestContext& testContext, 1273 glu::RenderContext& renderContext, 1274 TextureRenderer& renderer, 1275 tcu::ResultCollector& results, 1276 de::Random& rng, 1277 deUint32 name, 1278 const ImageInfo& info, 1279 const tcu::Texture2DArrayView& refTexture) 1280{ 1281 tcu::TestLog& log = testContext.getLog(); 1282 const glw::Functions& gl = renderContext.getFunctions(); 1283 const tcu::RGBA threshold = renderContext.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1); 1284 const tcu::TextureFormat format = refTexture.getLevel(0).getFormat(); 1285 const tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(format); 1286 1287 ReferenceParams renderParams (TEXTURETYPE_2D_ARRAY); 1288 1289 renderParams.samplerType = getSamplerType(format); 1290 renderParams.sampler = Sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::NEAREST_MIPMAP_NEAREST, Sampler::NEAREST); 1291 renderParams.colorScale = spec.lookupScale; 1292 renderParams.colorBias = spec.lookupBias; 1293 1294 gl.activeTexture(GL_TEXTURE0); 1295 gl.bindTexture(GL_TEXTURE_2D_ARRAY, name); 1296 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind texture."); 1297 1298 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 1299 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 1300 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 1301 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 1302 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup texture filtering state."); 1303 1304 for (int level = 0; level < getLevelCount(info); level++) 1305 { 1306 const IVec3 levelSize = getLevelSize(info.getTarget(), info.getSize(), level); 1307 1308 for (int layer = 0; layer < levelSize.z(); layer++) 1309 { 1310 const RandomViewport viewport (renderContext.getRenderTarget(), levelSize.x(), levelSize.y(), rng.getUint32()); 1311 tcu::Surface renderedFrame (viewport.width, viewport.height); 1312 tcu::Surface referenceFrame (viewport.width, viewport.height); 1313 vector<float> texCoord; 1314 1315 computeQuadTexCoord2DArray(texCoord, layer, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f)); 1316 1317 // Setup base viewport. 1318 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 1319 1320 // Draw. 1321 renderer.renderQuad(0, &texCoord[0], renderParams); 1322 glu::readPixels(renderContext, viewport.x, viewport.y, renderedFrame.getAccess()); 1323 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render and read pixels."); 1324 1325 // Compute reference. 1326 sampleTexture(SurfaceAccess(referenceFrame, renderContext.getRenderTarget().getPixelFormat()), refTexture, &texCoord[0], renderParams); 1327 1328 // Compare and log. 1329 if (!pixelThresholdCompare(log, ("Level" + de::toString(level) + "Layer" + de::toString(layer)).c_str(), ("Render level " + de::toString(level) + ", Layer" + de::toString(layer)).c_str(), referenceFrame, renderedFrame, threshold, tcu::COMPARE_LOG_ON_ERROR)) 1330 results.fail("Image comparison of level " + de::toString(level) + " and layer " + de::toString(layer) + " failed."); 1331 else 1332 log << TestLog::Message << "Image comparison of level " << level << " and layer " << layer << " passed." << TestLog::EndMessage; 1333 } 1334 } 1335 1336 gl.bindTexture(GL_TEXTURE_2D_ARRAY, 0); 1337 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unbind texture."); 1338} 1339 1340void verifyTexture2DArray (tcu::TestContext& testContext, 1341 glu::RenderContext& renderContext, 1342 TextureRenderer& textureRenderer, 1343 tcu::ResultCollector& results, 1344 de::Random& rng, 1345 deUint32 name, 1346 const vector<ArrayBuffer<deUint8> >& data, 1347 const ImageInfo& info) 1348{ 1349 if (glu::isCompressedFormat(info.getFormat())) 1350 { 1351 vector<de::ArrayBuffer<deUint8> > levelDatas; 1352 vector<tcu::PixelBufferAccess> levelAccesses; 1353 1354 decompressTexture(levelDatas, levelAccesses, renderContext, info, data); 1355 1356 { 1357 const tcu::Texture2DArrayView refTexture((int)levelAccesses.size(), &(levelAccesses[0])); 1358 1359 verifyTexture2DArrayView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1360 } 1361 } 1362 else 1363 { 1364 const vector<tcu::ConstPixelBufferAccess> levelAccesses = getLevelAccesses(data, info); 1365 const tcu::Texture2DArrayView refTexture ((int)levelAccesses.size(), &(levelAccesses[0])); 1366 1367 verifyTexture2DArrayView(testContext, renderContext, textureRenderer, results, rng, name, info, refTexture); 1368 } 1369} 1370 1371tcu::TextureFormat getReadPixelFormat (const tcu::TextureFormat& format) 1372{ 1373 switch (tcu::getTextureChannelClass(format.type)) 1374 { 1375 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT: 1376 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT: 1377 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT: 1378 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8); 1379 1380 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER: 1381 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32); 1382 1383 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER: 1384 return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT32); 1385 1386 default: 1387 DE_ASSERT(false); 1388 return tcu::TextureFormat(); 1389 } 1390} 1391 1392Vec4 calculateThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat) 1393{ 1394 DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT); 1395 DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT); 1396 1397 DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER); 1398 DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER); 1399 1400 DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER); 1401 DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER); 1402 1403 { 1404 const tcu::IVec4 srcBits = tcu::getTextureFormatBitDepth(sourceFormat); 1405 const tcu::IVec4 readBits = tcu::getTextureFormatBitDepth(readPixelsFormat); 1406 1407 return Vec4(1.0f) / ((tcu::IVec4(1) << (tcu::min(srcBits, readBits))) - tcu::IVec4(1)).cast<float>(); 1408 } 1409} 1410 1411void verifyRenderbuffer (tcu::TestContext& testContext, 1412 glu::RenderContext& renderContext, 1413 tcu::ResultCollector& results, 1414 deUint32 name, 1415 const vector<ArrayBuffer<deUint8> >& data, 1416 const ImageInfo& info) 1417{ 1418 const glw::Functions& gl = renderContext.getFunctions(); 1419 TestLog& log = testContext.getLog(); 1420 1421 const tcu::TextureFormat format = glu::mapGLInternalFormat(info.getFormat()); 1422 const IVec3 size = info.getSize(); 1423 const tcu::ConstPixelBufferAccess refRenderbuffer (format, size.x(), size.y(), 1, data[0].getPtr()); 1424 const tcu::TextureFormat readPixelsFormat = getReadPixelFormat(format); 1425 tcu::TextureLevel renderbuffer (readPixelsFormat, size.x(), size.y()); 1426 1427 DE_ASSERT(size.z() == 1); 1428 DE_ASSERT(data.size() == 1); 1429 1430 { 1431 glu::Framebuffer framebuffer(gl); 1432 1433 gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer); 1434 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create and bind framebuffer."); 1435 1436 gl.bindRenderbuffer(GL_RENDERBUFFER, name); 1437 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, name); 1438 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind and attach renderbuffer to framebuffer."); 1439 1440 glu::readPixels(renderContext, 0, 0, renderbuffer.getAccess()); 1441 1442 gl.bindRenderbuffer(GL_RENDERBUFFER, 0); 1443 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 1444 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to unbind renderbuffer and framebuffer."); 1445 } 1446 1447 if (isFloatFormat(info.getFormat())) 1448 { 1449 const tcu::UVec4 threshold (2, 2, 2, 2); 1450 1451 if (!(tcu::floatUlpThresholdCompare(log, "Image comparison", "Image comparison", refRenderbuffer, renderbuffer.getAccess(), threshold, tcu::COMPARE_LOG_ON_ERROR))) 1452 results.fail("Image comparison failed."); 1453 else 1454 log << TestLog::Message << "Image comarison passed." << TestLog::EndMessage; 1455 } 1456 else if (isIntFormat(info.getFormat()) || isUintFormat(info.getFormat())) 1457 { 1458 const tcu::UVec4 threshold (1, 1, 1, 1); 1459 1460 if (!(tcu::intThresholdCompare(log, "Image comparison", "Image comparison", refRenderbuffer, renderbuffer.getAccess(), threshold, tcu::COMPARE_LOG_ON_ERROR))) 1461 results.fail("Image comparison failed."); 1462 else 1463 log << TestLog::Message << "Image comarison passed." << TestLog::EndMessage; 1464 } 1465 else 1466 { 1467 const Vec4 threshold = calculateThreshold(format, readPixelsFormat); 1468 1469 if (!(tcu::floatThresholdCompare(log, "Image comparison", "Image comparison", refRenderbuffer, renderbuffer.getAccess(), threshold, tcu::COMPARE_LOG_ON_ERROR))) 1470 results.fail("Image comparison failed."); 1471 else 1472 log << TestLog::Message << "Image comarison passed." << TestLog::EndMessage; 1473 } 1474} 1475 1476void verify (tcu::TestContext& testContext, 1477 glu::RenderContext& renderContext, 1478 TextureRenderer& textureRenderer, 1479 tcu::ResultCollector& results, 1480 de::Random& rng, 1481 deUint32 name, 1482 const vector<ArrayBuffer<deUint8> >& data, 1483 const ImageInfo& info) 1484{ 1485 switch (info.getTarget()) 1486 { 1487 case GL_TEXTURE_2D: 1488 verifyTexture2D(testContext, renderContext, textureRenderer, results, rng, name, data, info); 1489 break; 1490 1491 case GL_TEXTURE_3D: 1492 verifyTexture3D(testContext, renderContext, textureRenderer, results, rng, name, data, info); 1493 break; 1494 1495 case GL_TEXTURE_CUBE_MAP: 1496 verifyTextureCubemap(testContext, renderContext, textureRenderer, results, rng, name, data, info); 1497 break; 1498 1499 case GL_TEXTURE_2D_ARRAY: 1500 verifyTexture2DArray(testContext, renderContext, textureRenderer, results, rng, name, data, info); 1501 break; 1502 1503 case GL_RENDERBUFFER: 1504 verifyRenderbuffer(testContext, renderContext, results, name, data, info); 1505 break; 1506 1507 default: 1508 DE_ASSERT(false); 1509 } 1510} 1511 1512void logTestImageInfo (TestLog& log, 1513 const ImageInfo& imageInfo) 1514{ 1515 log << TestLog::Message << "Target: " << targetToName(imageInfo.getTarget()) << TestLog::EndMessage; 1516 log << TestLog::Message << "Size: " << imageInfo.getSize() << TestLog::EndMessage; 1517 log << TestLog::Message << "Levels: " << getLevelCount(imageInfo) << TestLog::EndMessage; 1518 log << TestLog::Message << "Format: " << formatToName(imageInfo.getFormat()) << TestLog::EndMessage; 1519} 1520 1521void logTestInfo (TestLog& log, 1522 const ImageInfo& srcImageInfo, 1523 const ImageInfo& dstImageInfo) 1524{ 1525 tcu::ScopedLogSection section(log, "TestCaseInfo", "Test case info"); 1526 1527 log << TestLog::Message << "Testing copying from " << targetToName(srcImageInfo.getTarget()) << " to " << targetToName(dstImageInfo.getTarget()) << "." << TestLog::EndMessage; 1528 1529 { 1530 tcu::ScopedLogSection srcSection(log, "Source image info.", "Source image info."); 1531 logTestImageInfo(log, srcImageInfo); 1532 } 1533 1534 { 1535 tcu::ScopedLogSection dstSection(log, "Destination image info.", "Destination image info."); 1536 logTestImageInfo(log, dstImageInfo); 1537 } 1538} 1539 1540class CopyImageTest : public TestCase 1541{ 1542public: 1543 CopyImageTest (Context& context, 1544 const ImageInfo& srcImage, 1545 const ImageInfo& dstImage, 1546 const char* name, 1547 const char* description); 1548 1549 ~CopyImageTest (void); 1550 1551 void init (void); 1552 void deinit (void); 1553 1554 TestCase::IterateResult iterate (void); 1555 1556private: 1557 void logTestInfoIter (void); 1558 void createImagesIter (void); 1559 void destroyImagesIter (void); 1560 void verifySourceIter (void); 1561 void verifyDestinationIter (void); 1562 void copyImageIter (void); 1563 1564 struct State 1565 { 1566 State (int seed, 1567 tcu::TestLog& log, 1568 glu::RenderContext& renderContext) 1569 : rng (seed) 1570 , results (log) 1571 , srcImage (NULL) 1572 , dstImage (NULL) 1573 , textureRenderer (renderContext, log, glu::GLSL_VERSION_310_ES, glu::PRECISION_HIGHP) 1574 { 1575 } 1576 1577 ~State (void) 1578 { 1579 delete srcImage; 1580 delete dstImage; 1581 } 1582 1583 de::Random rng; 1584 tcu::ResultCollector results; 1585 glu::ObjectWrapper* srcImage; 1586 glu::ObjectWrapper* dstImage; 1587 TextureRenderer textureRenderer; 1588 1589 vector<ArrayBuffer<deUint8> > srcImageLevels; 1590 vector<ArrayBuffer<deUint8> > dstImageLevels; 1591 }; 1592 1593 const ImageInfo m_srcImageInfo; 1594 const ImageInfo m_dstImageInfo; 1595 1596 int m_iteration; 1597 State* m_state; 1598}; 1599 1600CopyImageTest::CopyImageTest (Context& context, 1601 const ImageInfo& srcImage, 1602 const ImageInfo& dstImage, 1603 const char* name, 1604 const char* description) 1605 : TestCase (context, name, description) 1606 , m_srcImageInfo (srcImage) 1607 , m_dstImageInfo (dstImage) 1608 1609 , m_iteration (0) 1610 , m_state (NULL) 1611{ 1612} 1613 1614CopyImageTest::~CopyImageTest (void) 1615{ 1616 deinit(); 1617} 1618 1619void checkFormatSupport (glu::ContextInfo& info, deUint32 format) 1620{ 1621 if (glu::isCompressedFormat(format)) 1622 { 1623 if (isAstcFormat(glu::mapGLCompressedTexFormat(format))) 1624 { 1625 if (!info.isExtensionSupported("GL_KHR_texture_compression_astc_ldr") 1626 && !info.isExtensionSupported("GL_KHR_texture_compression_astc_hdr") 1627 && !info.isExtensionSupported("GL_OES_texture_compression_astc")) 1628 throw tcu::NotSupportedError("Compressed astc texture not supported.", "", __FILE__, __LINE__); 1629 } 1630 else 1631 { 1632 if (!info.isCompressedTextureFormatSupported(format)) 1633 throw tcu::NotSupportedError("Compressed texture not supported.", "", __FILE__, __LINE__); 1634 } 1635 } 1636} 1637 1638void CopyImageTest::init (void) 1639{ 1640 de::UniquePtr<glu::ContextInfo> ctxInfo(glu::ContextInfo::create(m_context.getRenderContext())); 1641 1642 if (!ctxInfo->isExtensionSupported("GL_EXT_copy_image")) 1643 throw tcu::NotSupportedError("Extension GL_EXT_copy_image not supported.", "", __FILE__, __LINE__); 1644 1645 checkFormatSupport(*ctxInfo, m_srcImageInfo.getFormat()); 1646 checkFormatSupport(*ctxInfo, m_dstImageInfo.getFormat()); 1647 1648 { 1649 SeedBuilder builder; 1650 1651 builder << 903980 1652 << m_srcImageInfo 1653 << m_dstImageInfo; 1654 1655 m_state = new State(builder.get(), m_testCtx.getLog(), m_context.getRenderContext()); 1656 } 1657} 1658 1659void CopyImageTest::deinit (void) 1660{ 1661 delete m_state; 1662 m_state = NULL; 1663} 1664 1665void CopyImageTest::logTestInfoIter (void) 1666{ 1667 TestLog& log = m_testCtx.getLog(); 1668 1669 logTestInfo(log, m_srcImageInfo, m_dstImageInfo); 1670} 1671 1672void CopyImageTest::createImagesIter (void) 1673{ 1674 TestLog& log = m_testCtx.getLog(); 1675 glu::RenderContext& renderContext = m_context.getRenderContext(); 1676 const glw::Functions& gl = renderContext.getFunctions(); 1677 const deUint32 moreRestrictiveFormat = getMoreRestrictiveFormat(m_srcImageInfo.getFormat(), m_dstImageInfo.getFormat()); 1678 de::Random& rng = m_state->rng; 1679 1680 DE_ASSERT(!m_state->srcImage); 1681 DE_ASSERT(!m_state->dstImage); 1682 1683 m_state->srcImage = new glu::ObjectWrapper(gl, getObjectTraits(m_srcImageInfo)); 1684 m_state->dstImage = new glu::ObjectWrapper(gl, getObjectTraits(m_dstImageInfo)); 1685 1686 { 1687 glu::ObjectWrapper& srcImage = *m_state->srcImage; 1688 glu::ObjectWrapper& dstImage = *m_state->dstImage; 1689 1690 vector<ArrayBuffer<deUint8> >& srcImageLevels = m_state->srcImageLevels; 1691 vector<ArrayBuffer<deUint8> >& dstImageLevels = m_state->dstImageLevels; 1692 1693 log << TestLog::Message << "Creating source image." << TestLog::EndMessage; 1694 genImage(gl, rng, *srcImage, srcImageLevels, m_srcImageInfo, moreRestrictiveFormat); 1695 1696 log << TestLog::Message << "Creating destination image." << TestLog::EndMessage; 1697 genImage(gl, rng, *dstImage, dstImageLevels, m_dstImageInfo, moreRestrictiveFormat); 1698 } 1699} 1700 1701void CopyImageTest::destroyImagesIter (void) 1702{ 1703 TestLog& log = m_testCtx.getLog(); 1704 1705 log << TestLog::Message << "Deleting source image. " << TestLog::EndMessage; 1706 1707 delete m_state->srcImage; 1708 m_state->srcImage = NULL; 1709 m_state->srcImageLevels.clear(); 1710 1711 log << TestLog::Message << "Deleting destination image. " << TestLog::EndMessage; 1712 1713 delete m_state->dstImage; 1714 m_state->dstImage = NULL; 1715 m_state->dstImageLevels.clear(); 1716} 1717 1718void CopyImageTest::verifySourceIter (void) 1719{ 1720 TestLog& log = m_testCtx.getLog(); 1721 const tcu::ScopedLogSection sourceSection (log, "Source image verify.", "Source image verify."); 1722 1723 de::Random& rng = m_state->rng; 1724 tcu::ResultCollector& results = m_state->results; 1725 glu::ObjectWrapper& srcImage = *m_state->srcImage; 1726 vector<ArrayBuffer<deUint8> >& srcImageLevels = m_state->srcImageLevels; 1727 1728 log << TestLog::Message << "Verifying source image." << TestLog::EndMessage; 1729 1730 verify(m_testCtx, m_context.getRenderContext(), m_state->textureRenderer, results, rng, *srcImage, srcImageLevels, m_srcImageInfo); 1731} 1732 1733void CopyImageTest::verifyDestinationIter (void) 1734{ 1735 TestLog& log = m_testCtx.getLog(); 1736 const tcu::ScopedLogSection destinationSection (log, "Destination image verify.", "Destination image verify."); 1737 1738 de::Random& rng = m_state->rng; 1739 tcu::ResultCollector& results = m_state->results; 1740 glu::ObjectWrapper& dstImage = *m_state->dstImage; 1741 vector<ArrayBuffer<deUint8> >& dstImageLevels = m_state->dstImageLevels; 1742 1743 log << TestLog::Message << "Verifying destination image." << TestLog::EndMessage; 1744 1745 verify(m_testCtx, m_context.getRenderContext(), m_state->textureRenderer, results, rng, *dstImage, dstImageLevels, m_dstImageInfo); 1746} 1747 1748struct Copy 1749{ 1750 Copy (const IVec3& srcPos_, 1751 int srcLevel_, 1752 1753 const IVec3& dstPos_, 1754 int dstLevel_, 1755 1756 const IVec3& size_) 1757 : srcPos (srcPos_) 1758 , srcLevel (srcLevel_) 1759 1760 , dstPos (dstPos_) 1761 , dstLevel (dstLevel_) 1762 , size (size_) 1763 { 1764 } 1765 1766 IVec3 srcPos; 1767 int srcLevel; 1768 IVec3 dstPos; 1769 int dstLevel; 1770 IVec3 size; 1771}; 1772 1773int getLastFullLevel (const ImageInfo& info) 1774{ 1775 const int levelCount = getLevelCount(info); 1776 const IVec3 blockPixelSize = getTexelBlockPixelSize(info.getFormat()); 1777 1778 for (int level = 0; level < levelCount; level++) 1779 { 1780 const IVec3 levelSize = getLevelSize(info.getTarget(), info.getSize(), level); 1781 1782 if (levelSize.x() < blockPixelSize.x() || levelSize.y() < blockPixelSize.y() || levelSize.z() < blockPixelSize.z()) 1783 return level - 1; 1784 } 1785 1786 return levelCount -1; 1787} 1788 1789void generateCopies (vector<Copy>& copies, const ImageInfo& srcInfo, const ImageInfo& dstInfo) 1790{ 1791 const deUint32 srcTarget = srcInfo.getTarget(); 1792 const deUint32 dstTarget = dstInfo.getTarget(); 1793 1794 const bool srcIsTexture = isTextureTarget(srcInfo.getTarget()); 1795 const bool dstIsTexture = isTextureTarget(dstInfo.getTarget()); 1796 1797 const bool srcIsCube = srcTarget == GL_TEXTURE_CUBE_MAP; 1798 const bool dstIsCube = dstTarget == GL_TEXTURE_CUBE_MAP; 1799 1800 const IVec3 srcBlockPixelSize = getTexelBlockPixelSize(srcInfo.getFormat()); 1801 const IVec3 dstBlockPixelSize = getTexelBlockPixelSize(dstInfo.getFormat()); 1802 1803 const int levels[] = 1804 { 1805 0, 1, -1 1806 }; 1807 1808 for (int levelNdx = 0; levelNdx < (srcIsTexture || dstIsTexture ? DE_LENGTH_OF_ARRAY(levels) : 1); levelNdx++) 1809 { 1810 const int srcLevel = (srcIsTexture ? (levels[levelNdx] >= 0 ? levels[levelNdx] : getLastFullLevel(srcInfo)) : 0); 1811 const int dstLevel = (dstIsTexture ? (levels[levelNdx] >= 0 ? levels[levelNdx] : getLastFullLevel(dstInfo)) : 0); 1812 1813 const IVec3 srcSize = getLevelSize(srcInfo.getTarget(), srcInfo.getSize(), srcLevel); 1814 const IVec3 dstSize = getLevelSize(dstInfo.getTarget(), dstInfo.getSize(), dstLevel); 1815 1816 // \note These are rounded down 1817 const IVec3 srcCompleteBlockSize = IVec3(srcSize.x() / srcBlockPixelSize.x(), srcSize.y() / srcBlockPixelSize.y(), (srcIsCube ? 6 : srcSize.z() / srcBlockPixelSize.z())); 1818 const IVec3 dstCompleteBlockSize = IVec3(dstSize.x() / dstBlockPixelSize.x(), dstSize.y() / dstBlockPixelSize.y(), (dstIsCube ? 6 : dstSize.z() / dstBlockPixelSize.z())); 1819 1820 const IVec3 maxCopyBlockSize = tcu::min(srcCompleteBlockSize, dstCompleteBlockSize); 1821 1822 // \note These are rounded down 1823 const int copyBlockWidth = de::max((2 * (maxCopyBlockSize.x() / 4)) - 1, 1); 1824 const int copyBlockHeight = de::max((2 * (maxCopyBlockSize.y() / 4)) - 1, 1); 1825 const int copyBlockDepth = de::max((2 * (maxCopyBlockSize.z() / 4)) - 1, 1); 1826 1827 // Copy NPOT block from (0,0,0) to other corner on dst 1828 { 1829 const IVec3 copyBlockSize (copyBlockWidth, copyBlockHeight, copyBlockDepth); 1830 const IVec3 srcBlockPos (srcCompleteBlockSize - copyBlockSize); 1831 const IVec3 dstBlockPos (0, 0, 0); 1832 1833 const IVec3 srcPos (srcBlockPos * srcBlockPixelSize); 1834 const IVec3 dstPos (dstBlockPos * dstBlockPixelSize); 1835 const IVec3 copySize (copyBlockSize * srcBlockPixelSize); 1836 1837 copies.push_back(Copy(srcPos, srcLevel, dstPos, dstLevel, copySize)); 1838 } 1839 1840 // Copy NPOT block to (0,0,0) from other corner on src 1841 { 1842 const IVec3 copyBlockSize (copyBlockWidth, copyBlockHeight, copyBlockDepth); 1843 const IVec3 srcBlockPos (0, 0, 0); 1844 const IVec3 dstBlockPos (dstCompleteBlockSize - copyBlockSize); 1845 1846 const IVec3 srcPos (srcBlockPos * srcBlockPixelSize); 1847 const IVec3 dstPos (dstBlockPos * dstBlockPixelSize); 1848 const IVec3 copySize (copyBlockSize * srcBlockPixelSize); 1849 1850 copies.push_back(Copy(srcPos, srcLevel, dstPos, dstLevel, copySize)); 1851 } 1852 1853 // Copy NPOT block to (0,0,0) from other corner on src 1854 { 1855 const IVec3 copyBlockSize (copyBlockWidth, copyBlockHeight, copyBlockDepth); 1856 const IVec3 srcBlockPos (tcu::max((srcCompleteBlockSize / 4) * 4 - copyBlockSize, IVec3(0))); 1857 const IVec3 dstBlockPos (tcu::max((dstCompleteBlockSize / 4) * 4 - copyBlockSize, IVec3(0))); 1858 1859 const IVec3 srcPos (srcBlockPos * srcBlockPixelSize); 1860 const IVec3 dstPos (dstBlockPos * dstBlockPixelSize); 1861 const IVec3 copySize (copyBlockSize * srcBlockPixelSize); 1862 1863 copies.push_back(Copy(srcPos, srcLevel, dstPos, dstLevel, copySize)); 1864 } 1865 } 1866} 1867 1868void CopyImageTest::copyImageIter (void) 1869{ 1870 TestLog& log = m_testCtx.getLog(); 1871 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1872 glu::ObjectWrapper& srcImage = *m_state->srcImage; 1873 glu::ObjectWrapper& dstImage = *m_state->dstImage; 1874 1875 vector<ArrayBuffer<deUint8> >& srcImageLevels = m_state->srcImageLevels; 1876 vector<ArrayBuffer<deUint8> >& dstImageLevels = m_state->dstImageLevels; 1877 vector<Copy> copies; 1878 1879 generateCopies(copies, m_srcImageInfo, m_dstImageInfo); 1880 1881 for (int copyNdx = 0; copyNdx < (int)copies.size(); copyNdx++) 1882 { 1883 const Copy& copy = copies[copyNdx]; 1884 1885 log << TestLog::Message << "Copying block " << copy.size << " from source image position " << copy.srcPos << " and mipmap level " << copy.srcLevel 1886 << " to destination image position " << copy.dstPos << " and mipmap level " << copy.dstLevel << TestLog::EndMessage; 1887 1888 copyImage(gl, *dstImage, dstImageLevels, m_dstImageInfo, copy.dstLevel, copy.dstPos, 1889 *srcImage, srcImageLevels, m_srcImageInfo, copy.srcLevel, copy.srcPos, copy.size); 1890 } 1891} 1892 1893TestCase::IterateResult CopyImageTest::iterate (void) 1894{ 1895 void(CopyImageTest::*methods[])(void) = 1896 { 1897 &CopyImageTest::logTestInfoIter, 1898 1899 // Render both images and then copy and verify again. 1900 &CopyImageTest::createImagesIter, 1901 &CopyImageTest::verifySourceIter, 1902 &CopyImageTest::verifyDestinationIter, 1903 &CopyImageTest::copyImageIter, 1904 &CopyImageTest::verifySourceIter, 1905 &CopyImageTest::verifyDestinationIter, 1906 &CopyImageTest::destroyImagesIter, 1907 1908 // Create images and immediately copies between thew and verify. 1909 &CopyImageTest::createImagesIter, 1910 &CopyImageTest::copyImageIter, 1911 &CopyImageTest::verifySourceIter, 1912 &CopyImageTest::verifyDestinationIter, 1913 &CopyImageTest::destroyImagesIter 1914 }; 1915 1916 if (m_iteration < DE_LENGTH_OF_ARRAY(methods)) 1917 { 1918 (this->*methods[m_iteration])(); 1919 m_iteration++; 1920 return CONTINUE; 1921 } 1922 else 1923 { 1924 m_state->results.setTestContextResult(m_testCtx); 1925 return STOP; 1926 } 1927} 1928 1929class CopyImageTests : public TestCaseGroup 1930{ 1931public: 1932 CopyImageTests (Context& context); 1933 ~CopyImageTests (void); 1934 1935 void init (void); 1936 1937private: 1938 CopyImageTests (const CopyImageTests& other); 1939 CopyImageTests& operator= (const CopyImageTests& other); 1940}; 1941 1942CopyImageTests::CopyImageTests (Context& context) 1943 : TestCaseGroup (context, "copy_image", "Copy image tests for GL_EXT_copy_image.") 1944{ 1945} 1946 1947CopyImageTests::~CopyImageTests (void) 1948{ 1949} 1950 1951int smallestCommonMultiple (int a_, int b_) 1952{ 1953 int a = (a_ > b_ ? a_ : b_); 1954 int b = (a_ > b_ ? b_ : a_); 1955 int result = 1; 1956 1957 for (int i = b/2; i > 1; i--) 1958 { 1959 while ((a % i) == 0 && (b % i) == 0) 1960 { 1961 result *= i; 1962 a /= i; 1963 b /= i; 1964 } 1965 } 1966 1967 return result * a * b; 1968} 1969 1970IVec3 getTestedSize (deUint32 target, deUint32 format, const IVec3& targetSize) 1971{ 1972 const IVec3 texelBlockPixelSize = getTexelBlockPixelSize(format); 1973 const bool isCube = target == GL_TEXTURE_CUBE_MAP; 1974 const bool is3D = target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY; 1975 1976 if (isCube) 1977 { 1978 const int multiplier = smallestCommonMultiple(texelBlockPixelSize.x(), texelBlockPixelSize.y()); 1979 const int size = (1 + (targetSize.x() / multiplier)) * multiplier; 1980 1981 return IVec3(size, size, 1); 1982 } 1983 else if (is3D) 1984 { 1985 return (1 + (targetSize / texelBlockPixelSize)) * texelBlockPixelSize; 1986 } 1987 else 1988 { 1989 const int width = (1 + targetSize.x() / texelBlockPixelSize.x()) * texelBlockPixelSize.x(); 1990 const int height = ((targetSize.y() / texelBlockPixelSize.y()) - 1) * texelBlockPixelSize.y(); 1991 1992 return IVec3(width, height, 1); 1993 } 1994} 1995 1996void addCopyTests (TestCaseGroup* root, deUint32 srcFormat, deUint32 dstFormat) 1997{ 1998 const string groupName = string(formatToName(srcFormat)) + "_" + formatToName(dstFormat); 1999 TestCaseGroup* const group = new TestCaseGroup(root->getContext(), groupName.c_str(), groupName.c_str()); 2000 2001 const deUint32 targets[] = 2002 { 2003 GL_TEXTURE_2D, 2004 GL_TEXTURE_3D, 2005 GL_TEXTURE_CUBE_MAP, 2006 GL_TEXTURE_2D_ARRAY, 2007 GL_RENDERBUFFER 2008 }; 2009 2010 root->addChild(group); 2011 2012 for (int srcTargetNdx = 0; srcTargetNdx < DE_LENGTH_OF_ARRAY(targets); srcTargetNdx++) 2013 { 2014 const deUint32 srcTarget = targets[srcTargetNdx]; 2015 const IVec3 srcTexelBlockPixelSize = getTexelBlockPixelSize(srcFormat); 2016 const bool srcIs3D = srcTarget == GL_TEXTURE_2D_ARRAY || srcTarget == GL_TEXTURE_3D; 2017 2018 if (glu::isCompressedFormat(srcFormat) && srcTarget == GL_RENDERBUFFER) 2019 continue; 2020 2021 if (srcTarget == GL_RENDERBUFFER && !isColorRenderable(srcFormat)) 2022 continue; 2023 2024 if (glu::isCompressedFormat(srcFormat) && !tcu::isAstcFormat(glu::mapGLCompressedTexFormat(srcFormat)) && srcIs3D) 2025 continue; 2026 2027 for (int dstTargetNdx = 0; dstTargetNdx < DE_LENGTH_OF_ARRAY(targets); dstTargetNdx++) 2028 { 2029 const deUint32 dstTarget = targets[dstTargetNdx]; 2030 const IVec3 dstTexelBlockPixelSize = getTexelBlockPixelSize(dstFormat); 2031 const bool dstIs3D = dstTarget == GL_TEXTURE_2D_ARRAY || dstTarget == GL_TEXTURE_3D; 2032 2033 if (glu::isCompressedFormat(dstFormat) && dstTarget == GL_RENDERBUFFER) 2034 continue; 2035 2036 if (dstTarget == GL_RENDERBUFFER && !isColorRenderable(dstFormat)) 2037 continue; 2038 2039 if (glu::isCompressedFormat(dstFormat) && !tcu::isAstcFormat(glu::mapGLCompressedTexFormat(dstFormat)) && dstIs3D) 2040 continue; 2041 2042 const string targetTestName = string(targetToName(srcTarget)) + "_to_" + targetToName(dstTarget); 2043 2044 const IVec3 targetSize2D (128, 128, 1); 2045 const IVec3 targetSize3D (128, 128, 16); 2046 2047 const IVec3 targetPos2D (32, 32, 0); 2048 const IVec3 targetPos3D (16, 16, 2); 2049 const IVec3 targetCopySize (16, 16, 4); 2050 2051 const IVec3 srcSize = getTestedSize(srcTarget, srcFormat, (srcIs3D ? targetSize3D : targetSize2D)); 2052 const IVec3 dstSize = getTestedSize(dstTarget, dstFormat, (dstIs3D ? targetSize3D : targetSize2D)); 2053 2054 group->addChild(new CopyImageTest(root->getContext(), 2055 ImageInfo(srcFormat, srcTarget, srcSize), 2056 ImageInfo(dstFormat, dstTarget, dstSize), 2057 targetTestName.c_str(), targetTestName.c_str())); 2058 } 2059 } 2060} 2061 2062void CopyImageTests::init (void) 2063{ 2064 TestCaseGroup* const nonCompressedGroup = new TestCaseGroup(m_context, "non_compressed", "Test copying between textures."); 2065 TestCaseGroup* const compressedGroup = new TestCaseGroup(m_context, "compressed", "Test copying between compressed textures."); 2066 TestCaseGroup* const mixedGroup = new TestCaseGroup(m_context, "mixed", "Test copying between compressed and non-compressed textures."); 2067 2068 addChild(nonCompressedGroup); 2069 addChild(compressedGroup); 2070 addChild(mixedGroup); 2071 2072 map<ViewClass, vector<deUint32> > textureFormatViewClasses; 2073 map<ViewClass, vector<deUint32> > compressedTextureFormatViewClasses; 2074 map<ViewClass, pair<vector<deUint32>, vector<deUint32> > > mixedViewClasses; 2075 2076 // Texture view classes 2077 textureFormatViewClasses[VIEWCLASS_128_BITS] = vector<deUint32>(); 2078 textureFormatViewClasses[VIEWCLASS_96_BITS] = vector<deUint32>(); 2079 textureFormatViewClasses[VIEWCLASS_64_BITS] = vector<deUint32>(); 2080 textureFormatViewClasses[VIEWCLASS_48_BITS] = vector<deUint32>(); 2081 textureFormatViewClasses[VIEWCLASS_32_BITS] = vector<deUint32>(); 2082 textureFormatViewClasses[VIEWCLASS_24_BITS] = vector<deUint32>(); 2083 textureFormatViewClasses[VIEWCLASS_16_BITS] = vector<deUint32>(); 2084 textureFormatViewClasses[VIEWCLASS_8_BITS] = vector<deUint32>(); 2085 2086 // 128bit / VIEWCLASS_128_BITS 2087 textureFormatViewClasses[VIEWCLASS_128_BITS].push_back(GL_RGBA32F); 2088 textureFormatViewClasses[VIEWCLASS_128_BITS].push_back(GL_RGBA32I); 2089 textureFormatViewClasses[VIEWCLASS_128_BITS].push_back(GL_RGBA32UI); 2090 2091 // 96bit / VIEWCLASS_96_BITS 2092 textureFormatViewClasses[VIEWCLASS_96_BITS].push_back(GL_RGB32F); 2093 textureFormatViewClasses[VIEWCLASS_96_BITS].push_back(GL_RGB32I); 2094 textureFormatViewClasses[VIEWCLASS_96_BITS].push_back(GL_RGB32UI); 2095 2096 // 64bit / VIEWCLASS_64_BITS 2097 textureFormatViewClasses[VIEWCLASS_64_BITS].push_back(GL_RG32F); 2098 textureFormatViewClasses[VIEWCLASS_64_BITS].push_back(GL_RG32I); 2099 textureFormatViewClasses[VIEWCLASS_64_BITS].push_back(GL_RG32UI); 2100 2101 textureFormatViewClasses[VIEWCLASS_64_BITS].push_back(GL_RGBA16F); 2102 textureFormatViewClasses[VIEWCLASS_64_BITS].push_back(GL_RGBA16I); 2103 textureFormatViewClasses[VIEWCLASS_64_BITS].push_back(GL_RGBA16UI); 2104 2105 // 48bit / VIEWCLASS_48_BITS 2106 textureFormatViewClasses[VIEWCLASS_48_BITS].push_back(GL_RGB16F); 2107 textureFormatViewClasses[VIEWCLASS_48_BITS].push_back(GL_RGB16I); 2108 textureFormatViewClasses[VIEWCLASS_48_BITS].push_back(GL_RGB16UI); 2109 2110 // 32bit / VIEWCLASS_32_BITS 2111 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_R32F); 2112 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_R32I); 2113 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_R32UI); 2114 2115 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RG16F); 2116 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RG16I); 2117 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RG16UI); 2118 2119 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGBA8); 2120 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGBA8I); 2121 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGBA8UI); 2122 2123 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_R11F_G11F_B10F); 2124 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGB10_A2UI); 2125 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGB10_A2); 2126 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGBA8_SNORM); 2127 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_SRGB8_ALPHA8); 2128 textureFormatViewClasses[VIEWCLASS_32_BITS].push_back(GL_RGB9_E5); 2129 2130 // 24bit / VIEWCLASS_24_BITS 2131 textureFormatViewClasses[VIEWCLASS_24_BITS].push_back(GL_RGB8); 2132 textureFormatViewClasses[VIEWCLASS_24_BITS].push_back(GL_RGB8I); 2133 textureFormatViewClasses[VIEWCLASS_24_BITS].push_back(GL_RGB8UI); 2134 textureFormatViewClasses[VIEWCLASS_24_BITS].push_back(GL_RGB8_SNORM); 2135 textureFormatViewClasses[VIEWCLASS_24_BITS].push_back(GL_SRGB8); 2136 2137 // 16bit / VIEWCLASS_16_BITS 2138 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_R16F); 2139 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_R16I); 2140 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_R16UI); 2141 2142 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_RG8); 2143 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_RG8I); 2144 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_RG8UI); 2145 textureFormatViewClasses[VIEWCLASS_16_BITS].push_back(GL_RG8_SNORM); 2146 2147 // 8bit / VIEWCLASS_8_BITS 2148 textureFormatViewClasses[VIEWCLASS_8_BITS].push_back(GL_R8); 2149 textureFormatViewClasses[VIEWCLASS_8_BITS].push_back(GL_R8I); 2150 textureFormatViewClasses[VIEWCLASS_8_BITS].push_back(GL_R8UI); 2151 textureFormatViewClasses[VIEWCLASS_8_BITS].push_back(GL_R8_SNORM); 2152 2153 // Compressed texture view classes 2154 compressedTextureFormatViewClasses[VIEWCLASS_EAC_R11] = vector<deUint32>(); 2155 compressedTextureFormatViewClasses[VIEWCLASS_EAC_RG11] = vector<deUint32>(); 2156 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_RGB] = vector<deUint32>(); 2157 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_RGBA] = vector<deUint32>(); 2158 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_EAC_RGBA] = vector<deUint32>(); 2159 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA] = vector<deUint32>(); 2160 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA] = vector<deUint32>(); 2161 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA] = vector<deUint32>(); 2162 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA] = vector<deUint32>(); 2163 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA] = vector<deUint32>(); 2164 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA] = vector<deUint32>(); 2165 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA] = vector<deUint32>(); 2166 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA] = vector<deUint32>(); 2167 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA] = vector<deUint32>(); 2168 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA] = vector<deUint32>(); 2169 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA] = vector<deUint32>(); 2170 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA] = vector<deUint32>(); 2171 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA] = vector<deUint32>(); 2172 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA] = vector<deUint32>(); 2173 2174 // VIEWCLASS_EAC_R11 2175 compressedTextureFormatViewClasses[VIEWCLASS_EAC_R11].push_back(GL_COMPRESSED_R11_EAC); 2176 compressedTextureFormatViewClasses[VIEWCLASS_EAC_R11].push_back(GL_COMPRESSED_SIGNED_R11_EAC); 2177 2178 // VIEWCLASS_EAC_RG11 2179 compressedTextureFormatViewClasses[VIEWCLASS_EAC_RG11].push_back(GL_COMPRESSED_RG11_EAC); 2180 compressedTextureFormatViewClasses[VIEWCLASS_EAC_RG11].push_back(GL_COMPRESSED_SIGNED_RG11_EAC); 2181 2182 // VIEWCLASS_ETC2_RGB 2183 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_RGB].push_back(GL_COMPRESSED_RGB8_ETC2); 2184 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_RGB].push_back(GL_COMPRESSED_SRGB8_ETC2); 2185 2186 // VIEWCLASS_ETC2_RGBA 2187 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_RGBA].push_back(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2); 2188 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_RGBA].push_back(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2); 2189 2190 // VIEWCLASS_ETC2_EAC_RGBA 2191 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_EAC_RGBA].push_back(GL_COMPRESSED_RGBA8_ETC2_EAC); 2192 compressedTextureFormatViewClasses[VIEWCLASS_ETC2_EAC_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC); 2193 2194 // VIEWCLASS_ASTC_4x4_RGBA 2195 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_4x4_KHR); 2196 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR); 2197 2198 // VIEWCLASS_ASTC_5x4_RGBA 2199 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_5x4_KHR); 2200 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR); 2201 2202 // VIEWCLASS_ASTC_5x5_RGBA 2203 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_5x5_KHR); 2204 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR); 2205 2206 // VIEWCLASS_ASTC_6x5_RGBA 2207 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_6x5_KHR); 2208 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR); 2209 2210 // VIEWCLASS_ASTC_6x6_RGBA 2211 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_6x6_KHR); 2212 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR); 2213 2214 // VIEWCLASS_ASTC_8x5_RGBA 2215 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x5_KHR); 2216 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR); 2217 2218 // VIEWCLASS_ASTC_8x6_RGBA 2219 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x6_KHR); 2220 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR); 2221 2222 // VIEWCLASS_ASTC_8x8_RGBA 2223 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x8_KHR); 2224 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR); 2225 2226 // VIEWCLASS_ASTC_10x5_RGBA 2227 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x5_KHR); 2228 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR); 2229 2230 // VIEWCLASS_ASTC_10x6_RGBA 2231 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x6_KHR); 2232 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR); 2233 2234 // VIEWCLASS_ASTC_10x8_RGBA 2235 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x8_KHR); 2236 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR); 2237 2238 // VIEWCLASS_ASTC_10x10_RGBA 2239 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x10_KHR); 2240 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR); 2241 2242 // VIEWCLASS_ASTC_12x10_RGBA 2243 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_12x10_KHR); 2244 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR); 2245 2246 // VIEWCLASS_ASTC_12x12_RGBA 2247 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_12x12_KHR); 2248 compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR); 2249 2250 // Mixed view classes 2251 mixedViewClasses[VIEWCLASS_128_BITS] = pair<vector<deUint32>, vector<deUint32> >(); 2252 mixedViewClasses[VIEWCLASS_64_BITS] = pair<vector<deUint32>, vector<deUint32> >(); 2253 2254 // 128 bits 2255 2256 // Non compressed 2257 mixedViewClasses[VIEWCLASS_128_BITS].first.push_back(GL_RGBA32F); 2258 mixedViewClasses[VIEWCLASS_128_BITS].first.push_back(GL_RGBA32UI); 2259 mixedViewClasses[VIEWCLASS_128_BITS].first.push_back(GL_RGBA32I); 2260 2261 // Compressed 2262 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA8_ETC2_EAC); 2263 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC); 2264 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RG11_EAC); 2265 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SIGNED_RG11_EAC); 2266 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_4x4_KHR); 2267 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_5x4_KHR); 2268 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_5x5_KHR); 2269 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_6x5_KHR); 2270 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_6x6_KHR); 2271 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x5_KHR); 2272 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x6_KHR); 2273 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x8_KHR); 2274 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x5_KHR); 2275 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x6_KHR); 2276 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x8_KHR); 2277 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x10_KHR); 2278 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_12x10_KHR); 2279 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_12x12_KHR); 2280 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR); 2281 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR); 2282 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR); 2283 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR); 2284 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR); 2285 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR); 2286 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR); 2287 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR); 2288 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR); 2289 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR); 2290 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR); 2291 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR); 2292 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR); 2293 mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR); 2294 2295 // 64 bits 2296 2297 // Non compressed 2298 mixedViewClasses[VIEWCLASS_64_BITS].first.push_back(GL_RGBA16F); 2299 mixedViewClasses[VIEWCLASS_64_BITS].first.push_back(GL_RGBA16UI); 2300 mixedViewClasses[VIEWCLASS_64_BITS].first.push_back(GL_RGBA16I); 2301 2302 mixedViewClasses[VIEWCLASS_64_BITS].first.push_back(GL_RG32F); 2303 mixedViewClasses[VIEWCLASS_64_BITS].first.push_back(GL_RG32UI); 2304 mixedViewClasses[VIEWCLASS_64_BITS].first.push_back(GL_RG32I); 2305 2306 // Compressed 2307 mixedViewClasses[VIEWCLASS_64_BITS].second.push_back(GL_COMPRESSED_R11_EAC); 2308 mixedViewClasses[VIEWCLASS_64_BITS].second.push_back(GL_COMPRESSED_SIGNED_R11_EAC); 2309 2310 for (map<ViewClass, vector<deUint32> >::const_iterator viewClassIter = textureFormatViewClasses.begin(); viewClassIter != textureFormatViewClasses.end(); ++viewClassIter) 2311 { 2312 const vector<deUint32>& formats = viewClassIter->second; 2313 const ViewClass viewClass = viewClassIter->first; 2314 TestCaseGroup* const viewGroup = new TestCaseGroup(m_context, viewClassToName(viewClass), viewClassToName(viewClass)); 2315 2316 nonCompressedGroup->addChild(viewGroup); 2317 2318 for (int srcFormatNdx = 0; srcFormatNdx < (int)formats.size(); srcFormatNdx++) 2319 for (int dstFormatNdx = 0; dstFormatNdx < (int)formats.size(); dstFormatNdx++) 2320 { 2321 const deUint32 srcFormat = formats[srcFormatNdx]; 2322 const deUint32 dstFormat = formats[dstFormatNdx]; 2323 2324 if (srcFormat != dstFormat && isFloatFormat(srcFormat) && isFloatFormat(dstFormat)) 2325 continue; 2326 2327 addCopyTests(viewGroup, srcFormat, dstFormat); 2328 } 2329 } 2330 2331 for (map<ViewClass, vector<deUint32> >::const_iterator viewClassIter = compressedTextureFormatViewClasses.begin(); viewClassIter != compressedTextureFormatViewClasses.end(); ++viewClassIter) 2332 { 2333 const vector<deUint32>& formats = viewClassIter->second; 2334 const ViewClass viewClass = viewClassIter->first; 2335 TestCaseGroup* const viewGroup = new TestCaseGroup(m_context, viewClassToName(viewClass), viewClassToName(viewClass)); 2336 2337 compressedGroup->addChild(viewGroup); 2338 2339 for (int srcFormatNdx = 0; srcFormatNdx < (int)formats.size(); srcFormatNdx++) 2340 for (int dstFormatNdx = 0; dstFormatNdx < (int)formats.size(); dstFormatNdx++) 2341 { 2342 const deUint32 srcFormat = formats[srcFormatNdx]; 2343 const deUint32 dstFormat = formats[dstFormatNdx]; 2344 2345 if (srcFormat != dstFormat && isFloatFormat(srcFormat) && isFloatFormat(dstFormat)) 2346 continue; 2347 2348 addCopyTests(viewGroup, srcFormat, dstFormat); 2349 } 2350 } 2351 2352 for (map<ViewClass, pair<vector<deUint32>, vector<deUint32> > >::const_iterator iter = mixedViewClasses.begin(); iter != mixedViewClasses.end(); ++iter) 2353 { 2354 const ViewClass viewClass = iter->first; 2355 const string viewClassName = string(viewClassToName(viewClass)) + "_mixed"; 2356 TestCaseGroup* const viewGroup = new TestCaseGroup(m_context, viewClassName.c_str(), viewClassName.c_str()); 2357 2358 const vector<deUint32> nonCompressedFormats = iter->second.first; 2359 const vector<deUint32> compressedFormats = iter->second.second; 2360 2361 mixedGroup->addChild(viewGroup); 2362 2363 for (int srcFormatNdx = 0; srcFormatNdx < (int)nonCompressedFormats.size(); srcFormatNdx++) 2364 for (int dstFormatNdx = 0; dstFormatNdx < (int)compressedFormats.size(); dstFormatNdx++) 2365 { 2366 const deUint32 srcFormat = nonCompressedFormats[srcFormatNdx]; 2367 const deUint32 dstFormat = compressedFormats[dstFormatNdx]; 2368 2369 if (srcFormat != dstFormat && isFloatFormat(srcFormat) && isFloatFormat(dstFormat)) 2370 continue; 2371 2372 addCopyTests(viewGroup, srcFormat, dstFormat); 2373 addCopyTests(viewGroup, dstFormat, srcFormat); 2374 } 2375 } 2376} 2377 2378} // anonymous 2379 2380TestCaseGroup* createCopyImageTests (Context& context) 2381{ 2382 return new CopyImageTests(context); 2383} 2384 2385} // Functional 2386} // gles31 2387} // deqp 2388