1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 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 Texture specification tests. 22 * 23 * \todo [pyry] Following tests are missing: 24 * - Specify mipmap incomplete texture, use without mipmaps, re-specify 25 * as complete and render. 26 * - Randomly re-specify levels to eventually reach mipmap-complete texture. 27 *//*--------------------------------------------------------------------*/ 28 29 #include "es3fTextureSpecificationTests.hpp" 30 #include "tcuTestLog.hpp" 31 #include "tcuImageCompare.hpp" 32 #include "tcuTextureUtil.hpp" 33 #include "tcuVectorUtil.hpp" 34 #include "gluStrUtil.hpp" 35 #include "gluTexture.hpp" 36 #include "gluTextureUtil.hpp" 37 #include "sglrContextUtil.hpp" 38 #include "sglrContextWrapper.hpp" 39 #include "sglrGLContext.hpp" 40 #include "sglrReferenceContext.hpp" 41 #include "glsTextureTestUtil.hpp" 42 #include "deRandom.hpp" 43 #include "deStringUtil.hpp" 44 45 // \todo [2012-04-29 pyry] Should be named SglrUtil 46 #include "es3fFboTestUtil.hpp" 47 48 #include "glwEnums.hpp" 49 50 namespace deqp 51 { 52 namespace gles3 53 { 54 namespace Functional 55 { 56 57 using std::string; 58 using std::vector; 59 using std::pair; 60 using tcu::TestLog; 61 using tcu::Vec4; 62 using tcu::IVec4; 63 using tcu::UVec4; 64 using namespace FboTestUtil; 65 66 tcu::TextureFormat mapGLUnsizedInternalFormat (deUint32 internalFormat) 67 { 68 using tcu::TextureFormat; 69 switch (internalFormat) 70 { 71 case GL_ALPHA: return TextureFormat(TextureFormat::A, TextureFormat::UNORM_INT8); 72 case GL_LUMINANCE: return TextureFormat(TextureFormat::L, TextureFormat::UNORM_INT8); 73 case GL_LUMINANCE_ALPHA: return TextureFormat(TextureFormat::LA, TextureFormat::UNORM_INT8); 74 case GL_RGB: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8); 75 case GL_RGBA: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8); 76 default: 77 throw tcu::InternalError(string("Can't map GL unsized internal format (") + tcu::toHex(internalFormat).toString() + ") to texture format"); 78 } 79 } 80 81 enum 82 { 83 VIEWPORT_WIDTH = 256, 84 VIEWPORT_HEIGHT = 256 85 }; 86 87 static inline int maxLevelCount (int width, int height) 88 { 89 return (int)deLog2Floor32(de::max(width, height))+1; 90 } 91 92 static inline int maxLevelCount (int width, int height, int depth) 93 { 94 return (int)deLog2Floor32(de::max(width, de::max(height, depth)))+1; 95 } 96 97 template <int Size> 98 static tcu::Vector<float, Size> randomVector (de::Random& rnd, const tcu::Vector<float, Size>& minVal = tcu::Vector<float, Size>(0.0f), const tcu::Vector<float, Size>& maxVal = tcu::Vector<float, Size>(1.0f)) 99 { 100 tcu::Vector<float, Size> res; 101 for (int ndx = 0; ndx < Size; ndx++) 102 res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]); 103 return res; 104 } 105 106 static const deUint32 s_cubeMapFaces[] = 107 { 108 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 109 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 110 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 111 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 112 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 113 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 114 }; 115 116 static tcu::IVec4 getPixelFormatCompareDepth (const tcu::PixelFormat& pixelFormat, tcu::TextureFormat textureFormat) 117 { 118 switch (textureFormat.order) 119 { 120 case tcu::TextureFormat::L: 121 case tcu::TextureFormat::LA: 122 return tcu::IVec4(pixelFormat.redBits, pixelFormat.redBits, pixelFormat.redBits, pixelFormat.alphaBits); 123 default: 124 return tcu::IVec4(pixelFormat.redBits, pixelFormat.greenBits, pixelFormat.blueBits, pixelFormat.alphaBits); 125 } 126 } 127 128 static IVec4 getEffectiveTextureFormatBitDepth (tcu::TextureFormat textureFormat) 129 { 130 if (textureFormat.order == tcu::TextureFormat::DS) 131 { 132 // When sampling depth-stencil texture, we actually sample just 133 // the depth component. 134 return tcu::getTextureFormatBitDepth(tcu::getEffectiveDepthStencilTextureFormat(textureFormat, tcu::Sampler::MODE_DEPTH)); 135 } 136 else 137 return tcu::getTextureFormatBitDepth(textureFormat); 138 } 139 140 static tcu::UVec4 computeCompareThreshold (const tcu::PixelFormat& pixelFormat, tcu::TextureFormat textureFormat) 141 { 142 const IVec4 texFormatBits = getEffectiveTextureFormatBitDepth(textureFormat); 143 const IVec4 pixelFormatBits = getPixelFormatCompareDepth(pixelFormat, textureFormat); 144 const IVec4 accurateFmtBits = min(pixelFormatBits, texFormatBits); 145 const IVec4 compareBits = select(accurateFmtBits, IVec4(8), greaterThan(accurateFmtBits, IVec4(0))) - 1; 146 147 return (IVec4(1) << (8-compareBits)).asUint(); 148 } 149 150 class TextureSpecCase : public TestCase, public sglr::ContextWrapper 151 { 152 public: 153 TextureSpecCase (Context& context, const char* name, const char* desc); 154 ~TextureSpecCase (void); 155 156 IterateResult iterate (void); 157 158 protected: 159 virtual void createTexture (void) = DE_NULL; 160 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) = DE_NULL; 161 162 // Utilities. 163 void renderTex (tcu::Surface& dst, deUint32 program, int width, int height); 164 void readPixels (tcu::Surface& dst, int x, int y, int width, int height); 165 166 private: 167 TextureSpecCase (const TextureSpecCase& other); 168 TextureSpecCase& operator= (const TextureSpecCase& other); 169 }; 170 171 TextureSpecCase::TextureSpecCase (Context& context, const char* name, const char* desc) 172 : TestCase(context, name, desc) 173 { 174 } 175 176 TextureSpecCase::~TextureSpecCase (void) 177 { 178 } 179 180 TextureSpecCase::IterateResult TextureSpecCase::iterate (void) 181 { 182 glu::RenderContext& renderCtx = TestCase::m_context.getRenderContext(); 183 const tcu::RenderTarget& renderTarget = renderCtx.getRenderTarget(); 184 tcu::TestLog& log = m_testCtx.getLog(); 185 186 if (renderTarget.getWidth() < VIEWPORT_WIDTH || renderTarget.getHeight() < VIEWPORT_HEIGHT) 187 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__); 188 189 // Context size, and viewport for GLES3 190 de::Random rnd (deStringHash(getName())); 191 int width = deMin32(renderTarget.getWidth(), VIEWPORT_WIDTH); 192 int height = deMin32(renderTarget.getHeight(), VIEWPORT_HEIGHT); 193 int x = rnd.getInt(0, renderTarget.getWidth() - width); 194 int y = rnd.getInt(0, renderTarget.getHeight() - height); 195 196 // Contexts. 197 sglr::GLContext gles3Context (renderCtx, log, sglr::GLCONTEXT_LOG_CALLS, tcu::IVec4(x, y, width, height)); 198 sglr::ReferenceContextBuffers refBuffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), 0 /* depth */, 0 /* stencil */, width, height); 199 sglr::ReferenceContext refContext (sglr::ReferenceContextLimits(renderCtx), refBuffers.getColorbuffer(), refBuffers.getDepthbuffer(), refBuffers.getStencilbuffer()); 200 201 // Clear color buffer. 202 for (int ndx = 0; ndx < 2; ndx++) 203 { 204 setContext(ndx ? (sglr::Context*)&refContext : (sglr::Context*)&gles3Context); 205 glClearColor(0.125f, 0.25f, 0.5f, 1.0f); 206 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 207 } 208 209 // Construct texture using both GLES3 and reference contexts. 210 for (int ndx = 0; ndx < 2; ndx++) 211 { 212 setContext(ndx ? (sglr::Context*)&refContext : (sglr::Context*)&gles3Context); 213 createTexture(); 214 TCU_CHECK(glGetError() == GL_NO_ERROR); 215 } 216 217 // Initialize case result to pass. 218 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 219 220 // Disable logging. 221 gles3Context.enableLogging(0); 222 223 // Verify results. 224 verifyTexture(gles3Context, refContext); 225 226 return STOP; 227 } 228 229 void TextureSpecCase::renderTex (tcu::Surface& dst, deUint32 program, int width, int height) 230 { 231 int targetW = getWidth(); 232 int targetH = getHeight(); 233 234 float w = (float)width / (float)targetW; 235 float h = (float)height / (float)targetH; 236 237 sglr::drawQuad(*getCurrentContext(), program, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(-1.0f + w*2.0f, -1.0f + h*2.0f, 0.0f)); 238 239 // Read pixels back. 240 readPixels(dst, 0, 0, width, height); 241 } 242 243 void TextureSpecCase::readPixels (tcu::Surface& dst, int x, int y, int width, int height) 244 { 245 dst.setSize(width, height); 246 glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, dst.getAccess().getDataPtr()); 247 } 248 249 class Texture2DSpecCase : public TextureSpecCase 250 { 251 public: 252 Texture2DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLevels); 253 ~Texture2DSpecCase (void); 254 255 protected: 256 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext); 257 258 tcu::TextureFormat m_texFormat; 259 tcu::TextureFormatInfo m_texFormatInfo; 260 int m_width; 261 int m_height; 262 int m_numLevels; 263 }; 264 265 Texture2DSpecCase::Texture2DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLevels) 266 : TextureSpecCase (context, name, desc) 267 , m_texFormat (format) 268 , m_texFormatInfo (tcu::getTextureFormatInfo(format)) 269 , m_width (width) 270 , m_height (height) 271 , m_numLevels (numLevels) 272 { 273 } 274 275 Texture2DSpecCase::~Texture2DSpecCase (void) 276 { 277 } 278 279 void Texture2DSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) 280 { 281 Texture2DShader shader (DataTypes() << glu::getSampler2DType(m_texFormat), glu::TYPE_FLOAT_VEC4); 282 deUint32 shaderIDgles = gles3Context.createProgram(&shader); 283 deUint32 shaderIDRef = refContext.createProgram(&shader); 284 285 shader.setTexScaleBias(0, m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias); 286 287 // Set state. 288 for (int ndx = 0; ndx < 2; ndx++) 289 { 290 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 291 292 setContext(ctx); 293 294 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 295 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 296 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 297 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 298 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, m_numLevels-1); 299 } 300 301 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++) 302 { 303 int levelW = de::max(1, m_width >> levelNdx); 304 int levelH = de::max(1, m_height >> levelNdx); 305 tcu::Surface reference; 306 tcu::Surface result; 307 308 for (int ndx = 0; ndx < 2; ndx++) 309 { 310 tcu::Surface& dst = ndx ? reference : result; 311 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 312 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles; 313 314 setContext(ctx); 315 shader.setUniforms(*ctx, shaderID); 316 renderTex(dst, shaderID, levelW, levelH); 317 } 318 319 UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat); 320 string levelStr = de::toString(levelNdx); 321 string name = string("Level") + levelStr; 322 string desc = string("Level ") + levelStr; 323 bool isOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold, 324 levelNdx == 0 ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR); 325 326 if (!isOk) 327 { 328 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 329 break; 330 } 331 } 332 } 333 334 class TextureCubeSpecCase : public TextureSpecCase 335 { 336 public: 337 TextureCubeSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int size, int numLevels); 338 ~TextureCubeSpecCase (void); 339 340 protected: 341 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext); 342 343 tcu::TextureFormat m_texFormat; 344 tcu::TextureFormatInfo m_texFormatInfo; 345 int m_size; 346 int m_numLevels; 347 }; 348 349 TextureCubeSpecCase::TextureCubeSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int size, int numLevels) 350 : TextureSpecCase (context, name, desc) 351 , m_texFormat (format) 352 , m_texFormatInfo (tcu::getTextureFormatInfo(format)) 353 , m_size (size) 354 , m_numLevels (numLevels) 355 { 356 } 357 358 TextureCubeSpecCase::~TextureCubeSpecCase (void) 359 { 360 } 361 362 void TextureCubeSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) 363 { 364 TextureCubeShader shader (glu::getSamplerCubeType(m_texFormat), glu::TYPE_FLOAT_VEC4); 365 deUint32 shaderIDgles = gles3Context.createProgram(&shader); 366 deUint32 shaderIDRef = refContext.createProgram(&shader); 367 368 shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias); 369 370 // Set state. 371 for (int ndx = 0; ndx < 2; ndx++) 372 { 373 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 374 375 setContext(ctx); 376 377 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 378 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 379 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 380 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 381 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, m_numLevels-1); 382 } 383 384 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++) 385 { 386 int levelSize = de::max(1, m_size >> levelNdx); 387 bool isOk = true; 388 389 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 390 { 391 tcu::Surface reference; 392 tcu::Surface result; 393 394 if (levelSize <= 2) 395 continue; // Fuzzy compare doesn't work for images this small. 396 397 shader.setFace((tcu::CubeFace)face); 398 399 for (int ndx = 0; ndx < 2; ndx++) 400 { 401 tcu::Surface& dst = ndx ? reference : result; 402 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 403 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles; 404 405 setContext(ctx); 406 shader.setUniforms(*ctx, shaderID); 407 renderTex(dst, shaderID, levelSize, levelSize); 408 } 409 410 const float threshold = 0.02f; 411 string faceStr = de::toString((tcu::CubeFace)face); 412 string levelStr = de::toString(levelNdx); 413 string name = string("Level") + levelStr; 414 string desc = string("Level ") + levelStr + ", face " + faceStr; 415 bool isFaceOk = tcu::fuzzyCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference, result, threshold, 416 levelNdx == 0 ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR); 417 418 if (!isFaceOk) 419 { 420 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 421 isOk = false; 422 break; 423 } 424 } 425 426 if (!isOk) 427 break; 428 } 429 } 430 431 class Texture2DArraySpecCase : public TextureSpecCase 432 { 433 public: 434 Texture2DArraySpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLayers, int numLevels); 435 ~Texture2DArraySpecCase (void); 436 437 protected: 438 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext); 439 440 tcu::TextureFormat m_texFormat; 441 tcu::TextureFormatInfo m_texFormatInfo; 442 int m_width; 443 int m_height; 444 int m_numLayers; 445 int m_numLevels; 446 }; 447 448 Texture2DArraySpecCase::Texture2DArraySpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int numLayers, int numLevels) 449 : TextureSpecCase (context, name, desc) 450 , m_texFormat (format) 451 , m_texFormatInfo (tcu::getTextureFormatInfo(format)) 452 , m_width (width) 453 , m_height (height) 454 , m_numLayers (numLayers) 455 , m_numLevels (numLevels) 456 { 457 } 458 459 Texture2DArraySpecCase::~Texture2DArraySpecCase (void) 460 { 461 } 462 463 void Texture2DArraySpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) 464 { 465 Texture2DArrayShader shader (glu::getSampler2DArrayType(m_texFormat), glu::TYPE_FLOAT_VEC4); 466 deUint32 shaderIDgles = gles3Context.createProgram(&shader); 467 deUint32 shaderIDRef = refContext.createProgram(&shader); 468 469 shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias); 470 471 // Set state. 472 for (int ndx = 0; ndx < 2; ndx++) 473 { 474 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 475 476 setContext(ctx); 477 478 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 479 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 480 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 481 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 482 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 483 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, m_numLevels-1); 484 } 485 486 for (int layerNdx = 0; layerNdx < m_numLayers; layerNdx++) 487 { 488 bool layerOk = true; 489 490 shader.setLayer(layerNdx); 491 492 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++) 493 { 494 int levelW = de::max(1, m_width >> levelNdx); 495 int levelH = de::max(1, m_height >> levelNdx); 496 tcu::Surface reference; 497 tcu::Surface result; 498 499 for (int ndx = 0; ndx < 2; ndx++) 500 { 501 tcu::Surface& dst = ndx ? reference : result; 502 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 503 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles; 504 505 setContext(ctx); 506 shader.setUniforms(*ctx, shaderID); 507 renderTex(dst, shaderID, levelW, levelH); 508 } 509 510 UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat); 511 string levelStr = de::toString(levelNdx); 512 string layerStr = de::toString(layerNdx); 513 string name = string("Layer") + layerStr + "Level" + levelStr; 514 string desc = string("Layer ") + layerStr + ", Level " + levelStr; 515 bool depthOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold, 516 (levelNdx == 0 && layerNdx == 0) ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR); 517 518 if (!depthOk) 519 { 520 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 521 layerOk = false; 522 break; 523 } 524 } 525 526 if (!layerOk) 527 break; 528 } 529 } 530 531 class Texture3DSpecCase : public TextureSpecCase 532 { 533 public: 534 Texture3DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int depth, int numLevels); 535 ~Texture3DSpecCase (void); 536 537 protected: 538 virtual void verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext); 539 540 tcu::TextureFormat m_texFormat; 541 tcu::TextureFormatInfo m_texFormatInfo; 542 int m_width; 543 int m_height; 544 int m_depth; 545 int m_numLevels; 546 }; 547 548 Texture3DSpecCase::Texture3DSpecCase (Context& context, const char* name, const char* desc, const tcu::TextureFormat& format, int width, int height, int depth, int numLevels) 549 : TextureSpecCase (context, name, desc) 550 , m_texFormat (format) 551 , m_texFormatInfo (tcu::getTextureFormatInfo(format)) 552 , m_width (width) 553 , m_height (height) 554 , m_depth (depth) 555 , m_numLevels (numLevels) 556 { 557 } 558 559 Texture3DSpecCase::~Texture3DSpecCase (void) 560 { 561 } 562 563 void Texture3DSpecCase::verifyTexture (sglr::GLContext& gles3Context, sglr::ReferenceContext& refContext) 564 { 565 Texture3DShader shader (glu::getSampler3DType(m_texFormat), glu::TYPE_FLOAT_VEC4); 566 deUint32 shaderIDgles = gles3Context.createProgram(&shader); 567 deUint32 shaderIDRef = refContext.createProgram(&shader); 568 569 shader.setTexScaleBias(m_texFormatInfo.lookupScale, m_texFormatInfo.lookupBias); 570 571 // Set state. 572 for (int ndx = 0; ndx < 2; ndx++) 573 { 574 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 575 576 setContext(ctx); 577 578 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); 579 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 580 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 581 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 582 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 583 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, m_numLevels-1); 584 } 585 586 for (int levelNdx = 0; levelNdx < m_numLevels; levelNdx++) 587 { 588 int levelW = de::max(1, m_width >> levelNdx); 589 int levelH = de::max(1, m_height >> levelNdx); 590 int levelD = de::max(1, m_depth >> levelNdx); 591 bool levelOk = true; 592 593 for (int depth = 0; depth < levelD; depth++) 594 { 595 tcu::Surface reference; 596 tcu::Surface result; 597 598 shader.setDepth(((float)depth + 0.5f) / (float)levelD); 599 600 for (int ndx = 0; ndx < 2; ndx++) 601 { 602 tcu::Surface& dst = ndx ? reference : result; 603 sglr::Context* ctx = ndx ? static_cast<sglr::Context*>(&refContext) : static_cast<sglr::Context*>(&gles3Context); 604 deUint32 shaderID = ndx ? shaderIDRef : shaderIDgles; 605 606 setContext(ctx); 607 shader.setUniforms(*ctx, shaderID); 608 renderTex(dst, shaderID, levelW, levelH); 609 } 610 611 UVec4 threshold = computeCompareThreshold(m_context.getRenderTarget().getPixelFormat(), m_texFormat); 612 string levelStr = de::toString(levelNdx); 613 string sliceStr = de::toString(depth); 614 string name = string("Level") + levelStr + "Slice" + sliceStr; 615 string desc = string("Level ") + levelStr + ", Slice " + sliceStr; 616 bool depthOk = tcu::intThresholdCompare(m_testCtx.getLog(), name.c_str(), desc.c_str(), reference.getAccess(), result.getAccess(), threshold, 617 (levelNdx == 0 && depth == 0) ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR); 618 619 if (!depthOk) 620 { 621 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed"); 622 levelOk = false; 623 break; 624 } 625 } 626 627 if (!levelOk) 628 break; 629 } 630 } 631 632 // Basic TexImage2D() with 2D texture usage 633 class BasicTexImage2DCase : public Texture2DSpecCase 634 { 635 public: 636 // Unsized internal format. 637 BasicTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 638 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 639 , m_internalFormat (format) 640 , m_format (format) 641 , m_dataType (dataType) 642 { 643 } 644 645 // Sized internal format. 646 BasicTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 647 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height)) 648 , m_internalFormat (internalFormat) 649 , m_format (GL_NONE) 650 , m_dataType (GL_NONE) 651 { 652 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 653 m_format = fmt.format; 654 m_dataType = fmt.dataType; 655 } 656 657 protected: 658 void createTexture (void) 659 { 660 deUint32 tex = 0; 661 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType)); 662 de::Random rnd (deStringHash(getName())); 663 664 glGenTextures(1, &tex); 665 glBindTexture(GL_TEXTURE_2D, tex); 666 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 667 668 for (int ndx = 0; ndx < m_numLevels; ndx++) 669 { 670 int levelW = de::max(1, m_width >> ndx); 671 int levelH = de::max(1, m_height >> ndx); 672 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 673 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 674 675 levelData.setSize(levelW, levelH); 676 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 677 678 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, levelData.getAccess().getDataPtr()); 679 } 680 } 681 682 deUint32 m_internalFormat; 683 deUint32 m_format; 684 deUint32 m_dataType; 685 }; 686 687 // Basic TexImage2D() with cubemap usage 688 class BasicTexImageCubeCase : public TextureCubeSpecCase 689 { 690 public: 691 // Unsized formats. 692 BasicTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 693 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 694 , m_internalFormat (format) 695 , m_format (format) 696 , m_dataType (dataType) 697 { 698 } 699 700 // Sized internal formats. 701 BasicTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 702 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1) 703 , m_internalFormat (internalFormat) 704 , m_format (GL_NONE) 705 , m_dataType (GL_NONE) 706 { 707 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 708 m_format = fmt.format; 709 m_dataType = fmt.dataType; 710 } 711 712 protected: 713 void createTexture (void) 714 { 715 deUint32 tex = 0; 716 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType)); 717 de::Random rnd (deStringHash(getName())); 718 719 glGenTextures(1, &tex); 720 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 721 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 722 723 for (int ndx = 0; ndx < m_numLevels; ndx++) 724 { 725 int levelSize = de::max(1, m_size >> ndx); 726 727 levelData.setSize(levelSize, levelSize); 728 729 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 730 { 731 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 732 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 733 734 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 735 736 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, levelData.getAccess().getDataPtr()); 737 } 738 } 739 } 740 741 deUint32 m_internalFormat; 742 deUint32 m_format; 743 deUint32 m_dataType; 744 }; 745 746 // Basic TexImage3D() with 2D array texture usage 747 class BasicTexImage2DArrayCase : public Texture2DArraySpecCase 748 { 749 public: 750 BasicTexImage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers) 751 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, maxLevelCount(width, height)) 752 , m_internalFormat (internalFormat) 753 { 754 } 755 756 protected: 757 void createTexture (void) 758 { 759 deUint32 tex = 0; 760 de::Random rnd (deStringHash(getName())); 761 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 762 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 763 764 glGenTextures(1, &tex); 765 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 766 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 767 768 for (int ndx = 0; ndx < m_numLevels; ndx++) 769 { 770 int levelW = de::max(1, m_width >> ndx); 771 int levelH = de::max(1, m_height >> ndx); 772 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 773 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 774 775 levelData.setSize(levelW, levelH, m_numLayers); 776 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 777 778 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 779 } 780 } 781 782 deUint32 m_internalFormat; 783 }; 784 785 // Basic TexImage3D() with 3D texture usage 786 class BasicTexImage3DCase : public Texture3DSpecCase 787 { 788 public: 789 BasicTexImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth) 790 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth)) 791 , m_internalFormat (internalFormat) 792 { 793 } 794 795 protected: 796 void createTexture (void) 797 { 798 deUint32 tex = 0; 799 de::Random rnd (deStringHash(getName())); 800 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 801 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 802 803 glGenTextures(1, &tex); 804 glBindTexture(GL_TEXTURE_3D, tex); 805 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 806 807 for (int ndx = 0; ndx < m_numLevels; ndx++) 808 { 809 int levelW = de::max(1, m_width >> ndx); 810 int levelH = de::max(1, m_height >> ndx); 811 int levelD = de::max(1, m_depth >> ndx); 812 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 813 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 814 815 levelData.setSize(levelW, levelH, levelD); 816 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 817 818 glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 819 } 820 } 821 822 deUint32 m_internalFormat; 823 }; 824 825 // Randomized 2D texture specification using TexImage2D 826 class RandomOrderTexImage2DCase : public Texture2DSpecCase 827 { 828 public: 829 RandomOrderTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 830 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 831 , m_internalFormat (format) 832 , m_format (format) 833 , m_dataType (dataType) 834 { 835 } 836 837 RandomOrderTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 838 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height)) 839 , m_internalFormat (internalFormat) 840 , m_format (GL_NONE) 841 , m_dataType (GL_NONE) 842 { 843 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 844 m_format = fmt.format; 845 m_dataType = fmt.dataType; 846 } 847 848 protected: 849 void createTexture (void) 850 { 851 deUint32 tex = 0; 852 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType)); 853 de::Random rnd (deStringHash(getName())); 854 855 glGenTextures(1, &tex); 856 glBindTexture(GL_TEXTURE_2D, tex); 857 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 858 859 vector<int> levels (m_numLevels); 860 861 for (int i = 0; i < m_numLevels; i++) 862 levels[i] = i; 863 rnd.shuffle(levels.begin(), levels.end()); 864 865 for (int ndx = 0; ndx < m_numLevels; ndx++) 866 { 867 int levelNdx = levels[ndx]; 868 int levelW = de::max(1, m_width >> levelNdx); 869 int levelH = de::max(1, m_height >> levelNdx); 870 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 871 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 872 873 levelData.setSize(levelW, levelH); 874 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 875 876 glTexImage2D(GL_TEXTURE_2D, levelNdx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, levelData.getAccess().getDataPtr()); 877 } 878 } 879 880 deUint32 m_internalFormat; 881 deUint32 m_format; 882 deUint32 m_dataType; 883 }; 884 885 // Randomized cubemap texture specification using TexImage2D 886 class RandomOrderTexImageCubeCase : public TextureCubeSpecCase 887 { 888 public: 889 RandomOrderTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 890 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 891 , m_internalFormat (GL_NONE) 892 , m_format (format) 893 , m_dataType (dataType) 894 { 895 } 896 897 RandomOrderTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 898 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1) 899 , m_internalFormat (internalFormat) 900 , m_format (GL_NONE) 901 , m_dataType (GL_NONE) 902 { 903 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 904 m_format = fmt.format; 905 m_dataType = fmt.dataType; 906 } 907 908 protected: 909 void createTexture (void) 910 { 911 deUint32 tex = 0; 912 tcu::TextureLevel levelData (glu::mapGLTransferFormat(m_format, m_dataType)); 913 de::Random rnd (deStringHash(getName())); 914 915 glGenTextures(1, &tex); 916 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 917 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 918 919 // Level-face pairs. 920 vector<pair<int, tcu::CubeFace> > images (m_numLevels*6); 921 922 for (int ndx = 0; ndx < m_numLevels; ndx++) 923 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 924 images[ndx*6 + face] = std::make_pair(ndx, (tcu::CubeFace)face); 925 926 rnd.shuffle(images.begin(), images.end()); 927 928 for (int ndx = 0; ndx < (int)images.size(); ndx++) 929 { 930 int levelNdx = images[ndx].first; 931 tcu::CubeFace face = images[ndx].second; 932 int levelSize = de::max(1, m_size >> levelNdx); 933 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 934 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 935 936 levelData.setSize(levelSize, levelSize); 937 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 938 939 glTexImage2D(s_cubeMapFaces[face], levelNdx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, levelData.getAccess().getDataPtr()); 940 } 941 } 942 943 deUint32 m_internalFormat; 944 deUint32 m_format; 945 deUint32 m_dataType; 946 }; 947 948 // TexImage2D() unpack alignment case. 949 class TexImage2DAlignCase : public Texture2DSpecCase 950 { 951 public: 952 TexImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height, int numLevels, int alignment) 953 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, numLevels) 954 , m_internalFormat (format) 955 , m_format (format) 956 , m_dataType (dataType) 957 , m_alignment (alignment) 958 { 959 } 960 961 TexImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels, int alignment) 962 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels) 963 , m_internalFormat (internalFormat) 964 , m_format (GL_NONE) 965 , m_dataType (GL_NONE) 966 , m_alignment (alignment) 967 { 968 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 969 m_format = fmt.format; 970 m_dataType = fmt.dataType; 971 } 972 973 protected: 974 void createTexture (void) 975 { 976 deUint32 tex = 0; 977 vector<deUint8> data; 978 979 glGenTextures(1, &tex); 980 glBindTexture(GL_TEXTURE_2D, tex); 981 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 982 983 for (int ndx = 0; ndx < m_numLevels; ndx++) 984 { 985 int levelW = de::max(1, m_width >> ndx); 986 int levelH = de::max(1, m_height >> ndx); 987 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin; 988 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin; 989 int rowPitch = deAlign32(levelW*m_texFormat.getPixelSize(), m_alignment); 990 int cellSize = de::max(1, de::min(levelW >> 2, levelH >> 2)); 991 992 data.resize(rowPitch*levelH); 993 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, levelW, levelH, 1, rowPitch, 0, &data[0]), cellSize, colorA, colorB); 994 995 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, &data[0]); 996 } 997 } 998 999 deUint32 m_internalFormat; 1000 deUint32 m_format; 1001 deUint32 m_dataType; 1002 int m_alignment; 1003 }; 1004 1005 // TexImage2D() unpack alignment case. 1006 class TexImageCubeAlignCase : public TextureCubeSpecCase 1007 { 1008 public: 1009 TexImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size, int numLevels, int alignment) 1010 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, numLevels) 1011 , m_internalFormat (format) 1012 , m_format (format) 1013 , m_dataType (dataType) 1014 , m_alignment (alignment) 1015 { 1016 } 1017 1018 TexImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels, int alignment) 1019 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels) 1020 , m_internalFormat (internalFormat) 1021 , m_format (GL_NONE) 1022 , m_dataType (GL_NONE) 1023 , m_alignment (alignment) 1024 { 1025 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1026 m_format = fmt.format; 1027 m_dataType = fmt.dataType; 1028 } 1029 1030 protected: 1031 void createTexture (void) 1032 { 1033 deUint32 tex = 0; 1034 vector<deUint8> data; 1035 1036 glGenTextures(1, &tex); 1037 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1038 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1039 1040 for (int ndx = 0; ndx < m_numLevels; ndx++) 1041 { 1042 int levelSize = de::max(1, m_size >> ndx); 1043 int rowPitch = deAlign32(m_texFormat.getPixelSize()*levelSize, m_alignment); 1044 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin; 1045 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*(m_texFormatInfo.valueMax-m_texFormatInfo.valueMin) + m_texFormatInfo.valueMin; 1046 int cellSize = de::max(1, levelSize >> 2); 1047 1048 data.resize(rowPitch*levelSize); 1049 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, levelSize, levelSize, 1, rowPitch, 0, &data[0]), cellSize, colorA, colorB); 1050 1051 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1052 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, &data[0]); 1053 } 1054 } 1055 1056 deUint32 m_internalFormat; 1057 deUint32 m_format; 1058 deUint32 m_dataType; 1059 int m_alignment; 1060 }; 1061 1062 // TexImage2D() unpack parameters case. 1063 class TexImage2DParamsCase : public Texture2DSpecCase 1064 { 1065 public: 1066 TexImage2DParamsCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int rowLength, int skipRows, int skipPixels, int alignment) 1067 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 1068 , m_internalFormat (internalFormat) 1069 , m_rowLength (rowLength) 1070 , m_skipRows (skipRows) 1071 , m_skipPixels (skipPixels) 1072 , m_alignment (alignment) 1073 { 1074 } 1075 1076 protected: 1077 void createTexture (void) 1078 { 1079 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1080 int pixelSize = m_texFormat.getPixelSize(); 1081 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 1082 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1083 int height = m_height + m_skipRows; 1084 deUint32 tex = 0; 1085 vector<deUint8> data; 1086 1087 DE_ASSERT(m_numLevels == 1); 1088 1089 // Fill data with grid. 1090 data.resize(rowPitch*height); 1091 { 1092 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1093 Vec4 cBias = m_texFormatInfo.valueMin; 1094 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1095 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1096 1097 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB); 1098 } 1099 1100 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1101 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1102 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1103 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1104 1105 glGenTextures(1, &tex); 1106 glBindTexture(GL_TEXTURE_2D, tex); 1107 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1108 } 1109 1110 deUint32 m_internalFormat; 1111 int m_rowLength; 1112 int m_skipRows; 1113 int m_skipPixels; 1114 int m_alignment; 1115 }; 1116 1117 // TexImage3D() unpack parameters case. 1118 class TexImage3DParamsCase : public Texture3DSpecCase 1119 { 1120 public: 1121 TexImage3DParamsCase (Context& context, 1122 const char* name, 1123 const char* desc, 1124 deUint32 internalFormat, 1125 int width, 1126 int height, 1127 int depth, 1128 int imageHeight, 1129 int rowLength, 1130 int skipImages, 1131 int skipRows, 1132 int skipPixels, 1133 int alignment) 1134 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 1135 , m_internalFormat (internalFormat) 1136 , m_imageHeight (imageHeight) 1137 , m_rowLength (rowLength) 1138 , m_skipImages (skipImages) 1139 , m_skipRows (skipRows) 1140 , m_skipPixels (skipPixels) 1141 , m_alignment (alignment) 1142 { 1143 } 1144 1145 protected: 1146 void createTexture (void) 1147 { 1148 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1149 int pixelSize = m_texFormat.getPixelSize(); 1150 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 1151 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1152 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height; 1153 int slicePitch = imageHeight*rowPitch; 1154 deUint32 tex = 0; 1155 vector<deUint8> data; 1156 1157 DE_ASSERT(m_numLevels == 1); 1158 1159 // Fill data with grid. 1160 data.resize(slicePitch*(m_depth+m_skipImages)); 1161 { 1162 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1163 Vec4 cBias = m_texFormatInfo.valueMin; 1164 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1165 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1166 1167 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB); 1168 } 1169 1170 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 1171 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1172 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 1173 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1174 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1175 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1176 1177 glGenTextures(1, &tex); 1178 glBindTexture(GL_TEXTURE_3D, tex); 1179 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1180 } 1181 1182 deUint32 m_internalFormat; 1183 int m_imageHeight; 1184 int m_rowLength; 1185 int m_skipImages; 1186 int m_skipRows; 1187 int m_skipPixels; 1188 int m_alignment; 1189 }; 1190 1191 // Basic TexSubImage2D() with 2D texture usage 1192 class BasicTexSubImage2DCase : public Texture2DSpecCase 1193 { 1194 public: 1195 BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 1196 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 1197 , m_internalFormat (format) 1198 , m_format (format) 1199 , m_dataType (dataType) 1200 { 1201 } 1202 1203 BasicTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 1204 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height)) 1205 , m_internalFormat (internalFormat) 1206 , m_format (GL_NONE) 1207 , m_dataType (GL_NONE) 1208 { 1209 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1210 m_format = fmt.format; 1211 m_dataType = fmt.dataType; 1212 } 1213 1214 protected: 1215 void createTexture (void) 1216 { 1217 deUint32 tex = 0; 1218 tcu::TextureLevel data (m_texFormat); 1219 de::Random rnd (deStringHash(getName())); 1220 1221 glGenTextures(1, &tex); 1222 glBindTexture(GL_TEXTURE_2D, tex); 1223 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1224 1225 // First specify full texture. 1226 for (int ndx = 0; ndx < m_numLevels; ndx++) 1227 { 1228 int levelW = de::max(1, m_width >> ndx); 1229 int levelH = de::max(1, m_height >> ndx); 1230 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1231 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1232 1233 data.setSize(levelW, levelH); 1234 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1235 1236 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 1237 } 1238 1239 // Re-specify parts of each level. 1240 for (int ndx = 0; ndx < m_numLevels; ndx++) 1241 { 1242 int levelW = de::max(1, m_width >> ndx); 1243 int levelH = de::max(1, m_height >> ndx); 1244 1245 int w = rnd.getInt(1, levelW); 1246 int h = rnd.getInt(1, levelH); 1247 int x = rnd.getInt(0, levelW-w); 1248 int y = rnd.getInt(0, levelH-h); 1249 1250 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1251 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1252 int cellSize = rnd.getInt(2, 16); 1253 1254 data.setSize(w, h); 1255 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 1256 1257 glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr()); 1258 } 1259 } 1260 1261 deUint32 m_internalFormat; 1262 deUint32 m_format; 1263 deUint32 m_dataType; 1264 }; 1265 1266 // Basic TexSubImage2D() with cubemap usage 1267 class BasicTexSubImageCubeCase : public TextureCubeSpecCase 1268 { 1269 public: 1270 BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 1271 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 1272 , m_internalFormat (format) 1273 , m_format (format) 1274 , m_dataType (dataType) 1275 { 1276 } 1277 1278 BasicTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 1279 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1) 1280 , m_internalFormat (internalFormat) 1281 , m_format (GL_NONE) 1282 , m_dataType (GL_NONE) 1283 { 1284 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1285 m_format = fmt.format; 1286 m_dataType = fmt.dataType; 1287 } 1288 1289 protected: 1290 void createTexture (void) 1291 { 1292 deUint32 tex = 0; 1293 tcu::TextureLevel data (m_texFormat); 1294 de::Random rnd (deStringHash(getName())); 1295 1296 glGenTextures(1, &tex); 1297 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1298 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1299 1300 for (int ndx = 0; ndx < m_numLevels; ndx++) 1301 { 1302 int levelSize = de::max(1, m_size >> ndx); 1303 1304 data.setSize(levelSize, levelSize); 1305 1306 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1307 { 1308 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1309 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1310 1311 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1312 1313 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 1314 } 1315 } 1316 1317 // Re-specify parts of each face and level. 1318 for (int ndx = 0; ndx < m_numLevels; ndx++) 1319 { 1320 int levelSize = de::max(1, m_size >> ndx); 1321 1322 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1323 { 1324 int w = rnd.getInt(1, levelSize); 1325 int h = rnd.getInt(1, levelSize); 1326 int x = rnd.getInt(0, levelSize-w); 1327 int y = rnd.getInt(0, levelSize-h); 1328 1329 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1330 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1331 int cellSize = rnd.getInt(2, 16); 1332 1333 data.setSize(w, h); 1334 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 1335 1336 glTexSubImage2D(s_cubeMapFaces[face], ndx, x, y, w, h, m_format, m_dataType, data.getAccess().getDataPtr()); 1337 } 1338 } 1339 } 1340 1341 deUint32 m_internalFormat; 1342 deUint32 m_format; 1343 deUint32 m_dataType; 1344 }; 1345 1346 // TexSubImage2D() unpack parameters case. 1347 class TexSubImage2DParamsCase : public Texture2DSpecCase 1348 { 1349 public: 1350 TexSubImage2DParamsCase (Context& context, 1351 const char* name, 1352 const char* desc, 1353 deUint32 internalFormat, 1354 int width, 1355 int height, 1356 int subX, 1357 int subY, 1358 int subW, 1359 int subH, 1360 int rowLength, 1361 int skipRows, 1362 int skipPixels, 1363 int alignment) 1364 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 1365 , m_internalFormat (internalFormat) 1366 , m_subX (subX) 1367 , m_subY (subY) 1368 , m_subW (subW) 1369 , m_subH (subH) 1370 , m_rowLength (rowLength) 1371 , m_skipRows (skipRows) 1372 , m_skipPixels (skipPixels) 1373 , m_alignment (alignment) 1374 { 1375 } 1376 1377 protected: 1378 void createTexture (void) 1379 { 1380 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1381 int pixelSize = m_texFormat.getPixelSize(); 1382 deUint32 tex = 0; 1383 vector<deUint8> data; 1384 1385 DE_ASSERT(m_numLevels == 1); 1386 1387 glGenTextures(1, &tex); 1388 glBindTexture(GL_TEXTURE_2D, tex); 1389 1390 // First fill texture with gradient. 1391 data.resize(deAlign32(m_width*pixelSize, 4)*m_height); 1392 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, deAlign32(m_width*pixelSize, 4), 0, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1393 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1394 1395 // Fill data with grid. 1396 { 1397 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 1398 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1399 int height = m_subH + m_skipRows; 1400 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1401 Vec4 cBias = m_texFormatInfo.valueMin; 1402 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1403 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1404 1405 data.resize(rowPitch*height); 1406 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB); 1407 } 1408 1409 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1410 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1411 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1412 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1413 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, &data[0]); 1414 } 1415 1416 deUint32 m_internalFormat; 1417 int m_subX; 1418 int m_subY; 1419 int m_subW; 1420 int m_subH; 1421 int m_rowLength; 1422 int m_skipRows; 1423 int m_skipPixels; 1424 int m_alignment; 1425 }; 1426 1427 // Basic TexSubImage3D() with 3D texture usage 1428 class BasicTexSubImage3DCase : public Texture3DSpecCase 1429 { 1430 public: 1431 BasicTexSubImage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth) 1432 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, maxLevelCount(width, height, depth)) 1433 , m_internalFormat (internalFormat) 1434 { 1435 } 1436 1437 protected: 1438 void createTexture (void) 1439 { 1440 deUint32 tex = 0; 1441 tcu::TextureLevel data (m_texFormat); 1442 de::Random rnd (deStringHash(getName())); 1443 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1444 1445 glGenTextures(1, &tex); 1446 glBindTexture(GL_TEXTURE_3D, tex); 1447 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1448 1449 // First specify full texture. 1450 for (int ndx = 0; ndx < m_numLevels; ndx++) 1451 { 1452 int levelW = de::max(1, m_width >> ndx); 1453 int levelH = de::max(1, m_height >> ndx); 1454 int levelD = de::max(1, m_depth >> ndx); 1455 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1456 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1457 1458 data.setSize(levelW, levelH, levelD); 1459 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1460 1461 glTexImage3D(GL_TEXTURE_3D, ndx, m_internalFormat, levelW, levelH, levelD, 0, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr()); 1462 } 1463 1464 // Re-specify parts of each level. 1465 for (int ndx = 0; ndx < m_numLevels; ndx++) 1466 { 1467 int levelW = de::max(1, m_width >> ndx); 1468 int levelH = de::max(1, m_height >> ndx); 1469 int levelD = de::max(1, m_depth >> ndx); 1470 1471 int w = rnd.getInt(1, levelW); 1472 int h = rnd.getInt(1, levelH); 1473 int d = rnd.getInt(1, levelD); 1474 int x = rnd.getInt(0, levelW-w); 1475 int y = rnd.getInt(0, levelH-h); 1476 int z = rnd.getInt(0, levelD-d); 1477 1478 Vec4 colorA = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1479 Vec4 colorB = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1480 int cellSize = rnd.getInt(2, 16); 1481 1482 data.setSize(w, h, d); 1483 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 1484 1485 glTexSubImage3D(GL_TEXTURE_3D, ndx, x, y, z, w, h, d, transferFmt.format, transferFmt.dataType, data.getAccess().getDataPtr()); 1486 } 1487 } 1488 1489 deUint32 m_internalFormat; 1490 }; 1491 1492 // TexSubImage2D() to texture initialized with empty data 1493 class TexSubImage2DEmptyTexCase : public Texture2DSpecCase 1494 { 1495 public: 1496 TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 1497 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 1498 , m_internalFormat (format) 1499 , m_format (format) 1500 , m_dataType (dataType) 1501 { 1502 } 1503 1504 TexSubImage2DEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 1505 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, maxLevelCount(width, height)) 1506 , m_internalFormat (internalFormat) 1507 , m_format (GL_NONE) 1508 , m_dataType (GL_NONE) 1509 { 1510 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1511 m_format = fmt.format; 1512 m_dataType = fmt.dataType; 1513 } 1514 1515 protected: 1516 void createTexture (void) 1517 { 1518 deUint32 tex = 0; 1519 tcu::TextureLevel data (m_texFormat); 1520 de::Random rnd (deStringHash(getName())); 1521 1522 glGenTextures(1, &tex); 1523 glBindTexture(GL_TEXTURE_2D, tex); 1524 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1525 1526 // First allocate storage for each level. 1527 for (int ndx = 0; ndx < m_numLevels; ndx++) 1528 { 1529 int levelW = de::max(1, m_width >> ndx); 1530 int levelH = de::max(1, m_height >> ndx); 1531 1532 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, m_format, m_dataType, DE_NULL); 1533 } 1534 1535 // Specify pixel data to all levels using glTexSubImage2D() 1536 for (int ndx = 0; ndx < m_numLevels; ndx++) 1537 { 1538 int levelW = de::max(1, m_width >> ndx); 1539 int levelH = de::max(1, m_height >> ndx); 1540 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1541 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1542 1543 data.setSize(levelW, levelH); 1544 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1545 1546 glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, m_format, m_dataType, data.getAccess().getDataPtr()); 1547 } 1548 } 1549 1550 deUint32 m_internalFormat; 1551 deUint32 m_format; 1552 deUint32 m_dataType; 1553 }; 1554 1555 // TexSubImage2D() to empty cubemap texture 1556 class TexSubImageCubeEmptyTexCase : public TextureCubeSpecCase 1557 { 1558 public: 1559 TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 1560 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 1561 , m_internalFormat (format) 1562 , m_format (format) 1563 , m_dataType (dataType) 1564 { 1565 } 1566 1567 TexSubImageCubeEmptyTexCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 1568 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, deLog2Floor32(size)+1) 1569 , m_internalFormat (internalFormat) 1570 , m_format (GL_NONE) 1571 , m_dataType (GL_NONE) 1572 { 1573 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1574 m_format = fmt.format; 1575 m_dataType = fmt.dataType; 1576 } 1577 1578 protected: 1579 void createTexture (void) 1580 { 1581 deUint32 tex = 0; 1582 tcu::TextureLevel data (m_texFormat); 1583 de::Random rnd (deStringHash(getName())); 1584 1585 glGenTextures(1, &tex); 1586 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1587 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1588 1589 // Specify storage for each level. 1590 for (int ndx = 0; ndx < m_numLevels; ndx++) 1591 { 1592 int levelSize = de::max(1, m_size >> ndx); 1593 1594 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1595 glTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, levelSize, levelSize, 0, m_format, m_dataType, DE_NULL); 1596 } 1597 1598 // Specify data using glTexSubImage2D() 1599 for (int ndx = 0; ndx < m_numLevels; ndx++) 1600 { 1601 int levelSize = de::max(1, m_size >> ndx); 1602 1603 data.setSize(levelSize, levelSize); 1604 1605 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1606 { 1607 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1608 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1609 1610 tcu::fillWithComponentGradients(data.getAccess(), gMin, gMax); 1611 1612 glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, m_format, m_dataType, data.getAccess().getDataPtr()); 1613 } 1614 } 1615 } 1616 1617 deUint32 m_internalFormat; 1618 deUint32 m_format; 1619 deUint32 m_dataType; 1620 }; 1621 1622 // TexSubImage2D() unpack alignment with 2D texture 1623 class TexSubImage2DAlignCase : public Texture2DSpecCase 1624 { 1625 public: 1626 TexSubImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height, int subX, int subY, int subW, int subH, int alignment) 1627 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, 1) 1628 , m_internalFormat (format) 1629 , m_format (format) 1630 , m_dataType (dataType) 1631 , m_subX (subX) 1632 , m_subY (subY) 1633 , m_subW (subW) 1634 , m_subH (subH) 1635 , m_alignment (alignment) 1636 { 1637 } 1638 1639 TexSubImage2DAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int subX, int subY, int subW, int subH, int alignment) 1640 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 1641 , m_internalFormat (internalFormat) 1642 , m_format (GL_NONE) 1643 , m_dataType (GL_NONE) 1644 , m_subX (subX) 1645 , m_subY (subY) 1646 , m_subW (subW) 1647 , m_subH (subH) 1648 , m_alignment (alignment) 1649 { 1650 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1651 m_format = fmt.format; 1652 m_dataType = fmt.dataType; 1653 } 1654 1655 protected: 1656 void createTexture (void) 1657 { 1658 deUint32 tex = 0; 1659 vector<deUint8> data; 1660 1661 glGenTextures(1, &tex); 1662 glBindTexture(GL_TEXTURE_2D, tex); 1663 1664 // Specify base level. 1665 data.resize(m_texFormat.getPixelSize()*m_width*m_height); 1666 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, &data[0]), Vec4(0.0f), Vec4(1.0f)); 1667 1668 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1669 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, m_format, m_dataType, &data[0]); 1670 1671 // Re-specify subrectangle. 1672 int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment); 1673 data.resize(rowPitch*m_subH); 1674 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0]), 4, Vec4(1.0f, 0.0f, 0.0f, 1.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 1675 1676 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1677 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]); 1678 } 1679 1680 deUint32 m_internalFormat; 1681 deUint32 m_format; 1682 deUint32 m_dataType; 1683 int m_subX; 1684 int m_subY; 1685 int m_subW; 1686 int m_subH; 1687 int m_alignment; 1688 }; 1689 1690 // TexSubImage2D() unpack alignment with cubemap texture 1691 class TexSubImageCubeAlignCase : public TextureCubeSpecCase 1692 { 1693 public: 1694 TexSubImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size, int subX, int subY, int subW, int subH, int alignment) 1695 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, 1) 1696 , m_internalFormat (format) 1697 , m_format (format) 1698 , m_dataType (dataType) 1699 , m_subX (subX) 1700 , m_subY (subY) 1701 , m_subW (subW) 1702 , m_subH (subH) 1703 , m_alignment (alignment) 1704 { 1705 } 1706 1707 TexSubImageCubeAlignCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int subX, int subY, int subW, int subH, int alignment) 1708 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1) 1709 , m_internalFormat (internalFormat) 1710 , m_format (GL_NONE) 1711 , m_dataType (GL_NONE) 1712 , m_subX (subX) 1713 , m_subY (subY) 1714 , m_subW (subW) 1715 , m_subH (subH) 1716 , m_alignment (alignment) 1717 { 1718 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 1719 m_format = fmt.format; 1720 m_dataType = fmt.dataType; 1721 } 1722 1723 protected: 1724 void createTexture (void) 1725 { 1726 deUint32 tex = 0; 1727 vector<deUint8> data; 1728 1729 glGenTextures(1, &tex); 1730 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1731 1732 // Specify base level. 1733 data.resize(m_texFormat.getPixelSize()*m_size*m_size); 1734 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, &data[0]), Vec4(0.0f), Vec4(1.0f)); 1735 1736 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1737 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 1738 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, m_format, m_dataType, &data[0]); 1739 1740 // Re-specify subrectangle. 1741 int rowPitch = deAlign32(m_texFormat.getPixelSize()*m_subW, m_alignment); 1742 data.resize(rowPitch*m_subH); 1743 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0]), 4, Vec4(1.0f, 0.0f, 0.0f, 1.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 1744 1745 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1746 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 1747 glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, m_format, m_dataType, &data[0]); 1748 } 1749 1750 deUint32 m_internalFormat; 1751 deUint32 m_format; 1752 deUint32 m_dataType; 1753 int m_subX; 1754 int m_subY; 1755 int m_subW; 1756 int m_subH; 1757 int m_alignment; 1758 }; 1759 1760 // TexSubImage3D() unpack parameters case. 1761 class TexSubImage3DParamsCase : public Texture3DSpecCase 1762 { 1763 public: 1764 TexSubImage3DParamsCase (Context& context, 1765 const char* name, 1766 const char* desc, 1767 deUint32 internalFormat, 1768 int width, 1769 int height, 1770 int depth, 1771 int subX, 1772 int subY, 1773 int subZ, 1774 int subW, 1775 int subH, 1776 int subD, 1777 int imageHeight, 1778 int rowLength, 1779 int skipImages, 1780 int skipRows, 1781 int skipPixels, 1782 int alignment) 1783 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 1784 , m_internalFormat (internalFormat) 1785 , m_subX (subX) 1786 , m_subY (subY) 1787 , m_subZ (subZ) 1788 , m_subW (subW) 1789 , m_subH (subH) 1790 , m_subD (subD) 1791 , m_imageHeight (imageHeight) 1792 , m_rowLength (rowLength) 1793 , m_skipImages (skipImages) 1794 , m_skipRows (skipRows) 1795 , m_skipPixels (skipPixels) 1796 , m_alignment (alignment) 1797 { 1798 } 1799 1800 protected: 1801 void createTexture (void) 1802 { 1803 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 1804 int pixelSize = m_texFormat.getPixelSize(); 1805 deUint32 tex = 0; 1806 vector<deUint8> data; 1807 1808 DE_ASSERT(m_numLevels == 1); 1809 1810 glGenTextures(1, &tex); 1811 glBindTexture(GL_TEXTURE_3D, tex); 1812 1813 // Fill with gradient. 1814 { 1815 int rowPitch = deAlign32(pixelSize*m_width, 4); 1816 int slicePitch = rowPitch*m_height; 1817 1818 data.resize(slicePitch*m_depth); 1819 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 1820 } 1821 1822 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]); 1823 1824 // Fill data with grid. 1825 { 1826 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 1827 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 1828 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH; 1829 int slicePitch = imageHeight*rowPitch; 1830 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 1831 Vec4 cBias = m_texFormatInfo.valueMin; 1832 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 1833 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 1834 1835 data.resize(slicePitch*(m_depth+m_skipImages)); 1836 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, m_subD, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize), 4, colorA, colorB); 1837 } 1838 1839 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 1840 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 1841 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 1842 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 1843 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 1844 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 1845 glTexSubImage3D(GL_TEXTURE_3D, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, &data[0]); 1846 } 1847 1848 deUint32 m_internalFormat; 1849 int m_subX; 1850 int m_subY; 1851 int m_subZ; 1852 int m_subW; 1853 int m_subH; 1854 int m_subD; 1855 int m_imageHeight; 1856 int m_rowLength; 1857 int m_skipImages; 1858 int m_skipRows; 1859 int m_skipPixels; 1860 int m_alignment; 1861 }; 1862 1863 // Basic CopyTexImage2D() with 2D texture usage 1864 class BasicCopyTexImage2DCase : public Texture2DSpecCase 1865 { 1866 public: 1867 BasicCopyTexImage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height) 1868 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), width, height, maxLevelCount(width, height)) 1869 , m_internalFormat (internalFormat) 1870 { 1871 } 1872 1873 protected: 1874 void createTexture (void) 1875 { 1876 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 1877 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 1878 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 1879 tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat); 1880 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 1881 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 1882 deUint32 tex = 0; 1883 de::Random rnd (deStringHash(getName())); 1884 GradientShader shader (glu::TYPE_FLOAT_VEC4); 1885 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 1886 1887 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 1888 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 1889 1890 // Fill render target with gradient. 1891 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 1892 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 1893 1894 glGenTextures(1, &tex); 1895 glBindTexture(GL_TEXTURE_2D, tex); 1896 1897 for (int ndx = 0; ndx < m_numLevels; ndx++) 1898 { 1899 int levelW = de::max(1, m_width >> ndx); 1900 int levelH = de::max(1, m_height >> ndx); 1901 int x = rnd.getInt(0, getWidth() - levelW); 1902 int y = rnd.getInt(0, getHeight() - levelH); 1903 1904 glCopyTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, x, y, levelW, levelH, 0); 1905 } 1906 } 1907 1908 deUint32 m_internalFormat; 1909 }; 1910 1911 // Basic CopyTexImage2D() with cubemap usage 1912 class BasicCopyTexImageCubeCase : public TextureCubeSpecCase 1913 { 1914 public: 1915 BasicCopyTexImageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size) 1916 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(internalFormat, GL_UNSIGNED_BYTE), size, deLog2Floor32(size)+1) 1917 , m_internalFormat (internalFormat) 1918 { 1919 } 1920 1921 protected: 1922 void createTexture (void) 1923 { 1924 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 1925 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 1926 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 1927 tcu::TextureFormat fmt = mapGLUnsizedInternalFormat(m_internalFormat); 1928 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 1929 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 1930 deUint32 tex = 0; 1931 de::Random rnd (deStringHash(getName())); 1932 GradientShader shader (glu::TYPE_FLOAT_VEC4); 1933 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 1934 1935 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 1936 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 1937 1938 // Fill render target with gradient. 1939 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 1940 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 1941 1942 glGenTextures(1, &tex); 1943 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 1944 1945 for (int ndx = 0; ndx < m_numLevels; ndx++) 1946 { 1947 int levelSize = de::max(1, m_size >> ndx); 1948 1949 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 1950 { 1951 int x = rnd.getInt(0, getWidth() - levelSize); 1952 int y = rnd.getInt(0, getHeight() - levelSize); 1953 1954 glCopyTexImage2D(s_cubeMapFaces[face], ndx, m_internalFormat, x, y, levelSize, levelSize, 0); 1955 } 1956 } 1957 } 1958 1959 deUint32 m_internalFormat; 1960 }; 1961 1962 // Basic CopyTexSubImage2D() with 2D texture usage 1963 class BasicCopyTexSubImage2DCase : public Texture2DSpecCase 1964 { 1965 public: 1966 BasicCopyTexSubImage2DCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int width, int height) 1967 : Texture2DSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), width, height, maxLevelCount(width, height)) 1968 , m_format (format) 1969 , m_dataType (dataType) 1970 { 1971 } 1972 1973 protected: 1974 void createTexture (void) 1975 { 1976 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 1977 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 1978 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 1979 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType); 1980 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 1981 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 1982 deUint32 tex = 0; 1983 tcu::TextureLevel data (fmt); 1984 de::Random rnd (deStringHash(getName())); 1985 GradientShader shader (glu::TYPE_FLOAT_VEC4); 1986 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 1987 1988 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 1989 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 1990 1991 glGenTextures(1, &tex); 1992 glBindTexture(GL_TEXTURE_2D, tex); 1993 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 1994 1995 // First specify full texture. 1996 for (int ndx = 0; ndx < m_numLevels; ndx++) 1997 { 1998 int levelW = de::max(1, m_width >> ndx); 1999 int levelH = de::max(1, m_height >> ndx); 2000 2001 Vec4 colorA = randomVector<4>(rnd); 2002 Vec4 colorB = randomVector<4>(rnd); 2003 int cellSize = rnd.getInt(2, 16); 2004 2005 data.setSize(levelW, levelH); 2006 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 2007 2008 glTexImage2D(GL_TEXTURE_2D, ndx, m_format, levelW, levelH, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 2009 } 2010 2011 // Fill render target with gradient. 2012 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 2013 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 2014 2015 // Re-specify parts of each level. 2016 for (int ndx = 0; ndx < m_numLevels; ndx++) 2017 { 2018 int levelW = de::max(1, m_width >> ndx); 2019 int levelH = de::max(1, m_height >> ndx); 2020 2021 int w = rnd.getInt(1, levelW); 2022 int h = rnd.getInt(1, levelH); 2023 int xo = rnd.getInt(0, levelW-w); 2024 int yo = rnd.getInt(0, levelH-h); 2025 2026 int x = rnd.getInt(0, getWidth() - w); 2027 int y = rnd.getInt(0, getHeight() - h); 2028 2029 glCopyTexSubImage2D(GL_TEXTURE_2D, ndx, xo, yo, x, y, w, h); 2030 } 2031 } 2032 2033 deUint32 m_format; 2034 deUint32 m_dataType; 2035 }; 2036 2037 // Basic CopyTexSubImage2D() with cubemap usage 2038 class BasicCopyTexSubImageCubeCase : public TextureCubeSpecCase 2039 { 2040 public: 2041 BasicCopyTexSubImageCubeCase (Context& context, const char* name, const char* desc, deUint32 format, deUint32 dataType, int size) 2042 : TextureCubeSpecCase (context, name, desc, glu::mapGLTransferFormat(format, dataType), size, deLog2Floor32(size)+1) 2043 , m_format (format) 2044 , m_dataType (dataType) 2045 { 2046 } 2047 2048 protected: 2049 void createTexture (void) 2050 { 2051 const tcu::RenderTarget& renderTarget = TestCase::m_context.getRenderContext().getRenderTarget(); 2052 bool targetHasRGB = renderTarget.getPixelFormat().redBits > 0 && renderTarget.getPixelFormat().greenBits > 0 && renderTarget.getPixelFormat().blueBits > 0; 2053 bool targetHasAlpha = renderTarget.getPixelFormat().alphaBits > 0; 2054 tcu::TextureFormat fmt = glu::mapGLTransferFormat(m_format, m_dataType); 2055 bool texHasRGB = fmt.order != tcu::TextureFormat::A; 2056 bool texHasAlpha = fmt.order == tcu::TextureFormat::RGBA || fmt.order == tcu::TextureFormat::LA || fmt.order == tcu::TextureFormat::A; 2057 deUint32 tex = 0; 2058 tcu::TextureLevel data (fmt); 2059 de::Random rnd (deStringHash(getName())); 2060 GradientShader shader (glu::TYPE_FLOAT_VEC4); 2061 deUint32 shaderID = getCurrentContext()->createProgram(&shader); 2062 2063 if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha)) 2064 throw tcu::NotSupportedError("Copying from current framebuffer is not supported", "", __FILE__, __LINE__); 2065 2066 glGenTextures(1, &tex); 2067 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2068 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2069 2070 for (int ndx = 0; ndx < m_numLevels; ndx++) 2071 { 2072 int levelSize = de::max(1, m_size >> ndx); 2073 2074 data.setSize(levelSize, levelSize); 2075 2076 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2077 { 2078 Vec4 colorA = randomVector<4>(rnd); 2079 Vec4 colorB = randomVector<4>(rnd); 2080 int cellSize = rnd.getInt(2, 16); 2081 2082 tcu::fillWithGrid(data.getAccess(), cellSize, colorA, colorB); 2083 glTexImage2D(s_cubeMapFaces[face], ndx, m_format, levelSize, levelSize, 0, m_format, m_dataType, data.getAccess().getDataPtr()); 2084 } 2085 } 2086 2087 // Fill render target with gradient. 2088 shader.setGradient(*getCurrentContext(), shaderID, Vec4(0.0f), Vec4(1.0f)); 2089 sglr::drawQuad(*getCurrentContext(), shaderID, tcu::Vec3(-1.0f, -1.0f, 0.0f), tcu::Vec3(1.0f, 1.0f, 0.0f)); 2090 2091 // Re-specify parts of each face and level. 2092 for (int ndx = 0; ndx < m_numLevels; ndx++) 2093 { 2094 int levelSize = de::max(1, m_size >> ndx); 2095 2096 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2097 { 2098 int w = rnd.getInt(1, levelSize); 2099 int h = rnd.getInt(1, levelSize); 2100 int xo = rnd.getInt(0, levelSize-w); 2101 int yo = rnd.getInt(0, levelSize-h); 2102 2103 int x = rnd.getInt(0, getWidth() - w); 2104 int y = rnd.getInt(0, getHeight() - h); 2105 2106 glCopyTexSubImage2D(s_cubeMapFaces[face], ndx, xo, yo, x, y, w, h); 2107 } 2108 } 2109 } 2110 2111 deUint32 m_format; 2112 deUint32 m_dataType; 2113 }; 2114 2115 // Basic glTexStorage2D() with 2D texture usage 2116 class BasicTexStorage2DCase : public Texture2DSpecCase 2117 { 2118 public: 2119 BasicTexStorage2DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLevels) 2120 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLevels) 2121 , m_internalFormat (internalFormat) 2122 { 2123 } 2124 2125 protected: 2126 void createTexture (void) 2127 { 2128 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat); 2129 glu::TransferFormat transferFmt = glu::getTransferFormat(fmt); 2130 deUint32 tex = 0; 2131 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2132 de::Random rnd (deStringHash(getName())); 2133 2134 glGenTextures(1, &tex); 2135 glBindTexture(GL_TEXTURE_2D, tex); 2136 glTexStorage2D(GL_TEXTURE_2D, m_numLevels, m_internalFormat, m_width, m_height); 2137 2138 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2139 2140 for (int ndx = 0; ndx < m_numLevels; ndx++) 2141 { 2142 int levelW = de::max(1, m_width >> ndx); 2143 int levelH = de::max(1, m_height >> ndx); 2144 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2145 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2146 2147 levelData.setSize(levelW, levelH); 2148 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2149 2150 glTexSubImage2D(GL_TEXTURE_2D, ndx, 0, 0, levelW, levelH, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2151 } 2152 } 2153 2154 deUint32 m_internalFormat; 2155 }; 2156 2157 // Basic glTexStorage2D() with cubemap usage 2158 class BasicTexStorageCubeCase : public TextureCubeSpecCase 2159 { 2160 public: 2161 BasicTexStorageCubeCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int size, int numLevels) 2162 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, numLevels) 2163 , m_internalFormat (internalFormat) 2164 { 2165 } 2166 2167 protected: 2168 void createTexture (void) 2169 { 2170 tcu::TextureFormat fmt = glu::mapGLInternalFormat(m_internalFormat); 2171 glu::TransferFormat transferFmt = glu::getTransferFormat(fmt); 2172 deUint32 tex = 0; 2173 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2174 de::Random rnd (deStringHash(getName())); 2175 2176 glGenTextures(1, &tex); 2177 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2178 glTexStorage2D(GL_TEXTURE_CUBE_MAP, m_numLevels, m_internalFormat, m_size, m_size); 2179 2180 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2181 2182 for (int ndx = 0; ndx < m_numLevels; ndx++) 2183 { 2184 int levelSize = de::max(1, m_size >> ndx); 2185 2186 levelData.setSize(levelSize, levelSize); 2187 2188 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2189 { 2190 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2191 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2192 2193 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2194 2195 glTexSubImage2D(s_cubeMapFaces[face], ndx, 0, 0, levelSize, levelSize, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2196 } 2197 } 2198 } 2199 2200 deUint32 m_internalFormat; 2201 }; 2202 2203 // Basic glTexStorage3D() with 2D array texture usage 2204 class BasicTexStorage2DArrayCase : public Texture2DArraySpecCase 2205 { 2206 public: 2207 BasicTexStorage2DArrayCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int numLayers, int numLevels) 2208 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, numLayers, numLevels) 2209 , m_internalFormat (internalFormat) 2210 { 2211 } 2212 2213 protected: 2214 void createTexture (void) 2215 { 2216 deUint32 tex = 0; 2217 de::Random rnd (deStringHash(getName())); 2218 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2219 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2220 2221 glGenTextures (1, &tex); 2222 glBindTexture (GL_TEXTURE_2D_ARRAY, tex); 2223 glTexStorage3D (GL_TEXTURE_2D_ARRAY, m_numLevels, m_internalFormat, m_width, m_height, m_numLayers); 2224 2225 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 2226 2227 for (int ndx = 0; ndx < m_numLevels; ndx++) 2228 { 2229 int levelW = de::max(1, m_width >> ndx); 2230 int levelH = de::max(1, m_height >> ndx); 2231 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2232 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2233 2234 levelData.setSize(levelW, levelH, m_numLayers); 2235 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2236 2237 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, 0, 0, 0, levelW, levelH, m_numLayers, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2238 } 2239 } 2240 2241 deUint32 m_internalFormat; 2242 }; 2243 2244 // Basic TexStorage3D() with 3D texture usage 2245 class BasicTexStorage3DCase : public Texture3DSpecCase 2246 { 2247 public: 2248 BasicTexStorage3DCase (Context& context, const char* name, const char* desc, deUint32 internalFormat, int width, int height, int depth, int numLevels) 2249 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, numLevels) 2250 , m_internalFormat (internalFormat) 2251 { 2252 } 2253 2254 protected: 2255 void createTexture (void) 2256 { 2257 deUint32 tex = 0; 2258 de::Random rnd (deStringHash(getName())); 2259 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2260 tcu::TextureLevel levelData (glu::mapGLTransferFormat(transferFmt.format, transferFmt.dataType)); 2261 2262 glGenTextures (1, &tex); 2263 glBindTexture (GL_TEXTURE_3D, tex); 2264 glTexStorage3D (GL_TEXTURE_3D, m_numLevels, m_internalFormat, m_width, m_height, m_depth); 2265 2266 glPixelStorei (GL_UNPACK_ALIGNMENT, 1); 2267 2268 for (int ndx = 0; ndx < m_numLevels; ndx++) 2269 { 2270 int levelW = de::max(1, m_width >> ndx); 2271 int levelH = de::max(1, m_height >> ndx); 2272 int levelD = de::max(1, m_depth >> ndx); 2273 Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2274 Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2275 2276 levelData.setSize(levelW, levelH, levelD); 2277 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 2278 2279 glTexSubImage3D(GL_TEXTURE_3D, ndx, 0, 0, 0, levelW, levelH, levelD, transferFmt.format, transferFmt.dataType, levelData.getAccess().getDataPtr()); 2280 } 2281 } 2282 2283 deUint32 m_internalFormat; 2284 }; 2285 2286 // Pixel buffer object cases. 2287 2288 // TexImage2D() from pixel buffer object. 2289 class TexImage2DBufferCase : public Texture2DSpecCase 2290 { 2291 public: 2292 TexImage2DBufferCase (Context& context, 2293 const char* name, 2294 const char* desc, 2295 deUint32 internalFormat, 2296 int width, 2297 int height, 2298 int rowLength, 2299 int skipRows, 2300 int skipPixels, 2301 int alignment, 2302 int offset) 2303 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 2304 , m_internalFormat (internalFormat) 2305 , m_rowLength (rowLength) 2306 , m_skipRows (skipRows) 2307 , m_skipPixels (skipPixels) 2308 , m_alignment (alignment) 2309 , m_offset (offset) 2310 { 2311 } 2312 2313 protected: 2314 void createTexture (void) 2315 { 2316 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2317 int pixelSize = m_texFormat.getPixelSize(); 2318 int rowLength = m_rowLength > 0 ? m_rowLength : m_width + m_skipPixels; 2319 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2320 int height = m_height + m_skipRows; 2321 deUint32 buf = 0; 2322 deUint32 tex = 0; 2323 vector<deUint8> data; 2324 2325 DE_ASSERT(m_numLevels == 1); 2326 2327 // Fill data with grid. 2328 data.resize(rowPitch*height + m_offset); 2329 { 2330 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2331 Vec4 cBias = m_texFormatInfo.valueMin; 2332 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2333 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2334 2335 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2336 } 2337 2338 // Create buffer and upload. 2339 glGenBuffers(1, &buf); 2340 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2341 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2342 2343 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2344 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2345 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2346 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2347 2348 glGenTextures(1, &tex); 2349 glBindTexture(GL_TEXTURE_2D, tex); 2350 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2351 } 2352 2353 deUint32 m_internalFormat; 2354 int m_rowLength; 2355 int m_skipRows; 2356 int m_skipPixels; 2357 int m_alignment; 2358 int m_offset; 2359 }; 2360 2361 // TexImage2D() cubemap from pixel buffer object case 2362 class TexImageCubeBufferCase : public TextureCubeSpecCase 2363 { 2364 public: 2365 TexImageCubeBufferCase (Context& context, 2366 const char* name, 2367 const char* desc, 2368 deUint32 internalFormat, 2369 int size, 2370 int rowLength, 2371 int skipRows, 2372 int skipPixels, 2373 int alignment, 2374 int offset) 2375 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1) 2376 , m_internalFormat (internalFormat) 2377 , m_rowLength (rowLength) 2378 , m_skipRows (skipRows) 2379 , m_skipPixels (skipPixels) 2380 , m_alignment (alignment) 2381 , m_offset (offset) 2382 { 2383 } 2384 2385 protected: 2386 void createTexture (void) 2387 { 2388 de::Random rnd (deStringHash(getName())); 2389 deUint32 tex = 0; 2390 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 2391 const int pixelSize = m_texFormat.getPixelSize(); 2392 const int rowLength = m_rowLength > 0 ? m_rowLength : m_size + m_skipPixels; 2393 const int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2394 const int height = m_size + m_skipRows; 2395 vector<vector<deUint8> > data (DE_LENGTH_OF_ARRAY(s_cubeMapFaces)); 2396 2397 DE_ASSERT(m_numLevels == 1); 2398 2399 glGenTextures(1, &tex); 2400 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2401 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2402 2403 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2404 { 2405 deUint32 buf = 0; 2406 2407 { 2408 const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2409 const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2410 2411 data[face].resize(rowPitch*height + m_offset); 2412 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, rowPitch, 0, &data[face][0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), gMin, gMax); 2413 } 2414 2415 // Create buffer and upload. 2416 glGenBuffers(1, &buf); 2417 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2418 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data[face].size(), &data[face][0], GL_STATIC_DRAW); 2419 2420 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2421 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2422 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2423 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2424 2425 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, fmt.format, fmt.dataType, (const void*)(deUintptr)m_offset); 2426 } 2427 } 2428 2429 deUint32 m_internalFormat; 2430 int m_rowLength; 2431 int m_skipRows; 2432 int m_skipPixels; 2433 int m_alignment; 2434 int m_offset; 2435 }; 2436 2437 // TexImage3D() 2D array from pixel buffer object. 2438 class TexImage2DArrayBufferCase : public Texture2DArraySpecCase 2439 { 2440 public: 2441 TexImage2DArrayBufferCase (Context& context, 2442 const char* name, 2443 const char* desc, 2444 deUint32 internalFormat, 2445 int width, 2446 int height, 2447 int depth, 2448 int imageHeight, 2449 int rowLength, 2450 int skipImages, 2451 int skipRows, 2452 int skipPixels, 2453 int alignment, 2454 int offset) 2455 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2456 , m_internalFormat (internalFormat) 2457 , m_imageHeight (imageHeight) 2458 , m_rowLength (rowLength) 2459 , m_skipImages (skipImages) 2460 , m_skipRows (skipRows) 2461 , m_skipPixels (skipPixels) 2462 , m_alignment (alignment) 2463 , m_offset (offset) 2464 { 2465 } 2466 2467 protected: 2468 void createTexture (void) 2469 { 2470 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2471 int pixelSize = m_texFormat.getPixelSize(); 2472 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 2473 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2474 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height; 2475 int slicePitch = imageHeight*rowPitch; 2476 deUint32 tex = 0; 2477 deUint32 buf = 0; 2478 vector<deUint8> data; 2479 2480 DE_ASSERT(m_numLevels == 1); 2481 2482 // Fill data with grid. 2483 data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset); 2484 { 2485 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2486 Vec4 cBias = m_texFormatInfo.valueMin; 2487 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2488 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2489 2490 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2491 } 2492 2493 glGenBuffers(1, &buf); 2494 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2495 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2496 2497 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2498 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2499 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2500 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2501 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2502 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2503 2504 glGenTextures(1, &tex); 2505 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 2506 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2507 } 2508 2509 deUint32 m_internalFormat; 2510 int m_imageHeight; 2511 int m_rowLength; 2512 int m_skipImages; 2513 int m_skipRows; 2514 int m_skipPixels; 2515 int m_alignment; 2516 int m_offset; 2517 }; 2518 2519 // TexImage3D() from pixel buffer object. 2520 class TexImage3DBufferCase : public Texture3DSpecCase 2521 { 2522 public: 2523 TexImage3DBufferCase (Context& context, 2524 const char* name, 2525 const char* desc, 2526 deUint32 internalFormat, 2527 int width, 2528 int height, 2529 int depth, 2530 int imageHeight, 2531 int rowLength, 2532 int skipImages, 2533 int skipRows, 2534 int skipPixels, 2535 int alignment, 2536 int offset) 2537 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2538 , m_internalFormat (internalFormat) 2539 , m_imageHeight (imageHeight) 2540 , m_rowLength (rowLength) 2541 , m_skipImages (skipImages) 2542 , m_skipRows (skipRows) 2543 , m_skipPixels (skipPixels) 2544 , m_alignment (alignment) 2545 , m_offset (offset) 2546 { 2547 } 2548 2549 protected: 2550 void createTexture (void) 2551 { 2552 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2553 int pixelSize = m_texFormat.getPixelSize(); 2554 int rowLength = m_rowLength > 0 ? m_rowLength : m_width; 2555 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2556 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_height; 2557 int slicePitch = imageHeight*rowPitch; 2558 deUint32 tex = 0; 2559 deUint32 buf = 0; 2560 vector<deUint8> data; 2561 2562 DE_ASSERT(m_numLevels == 1); 2563 2564 // Fill data with grid. 2565 data.resize(slicePitch*(m_depth+m_skipImages) + m_offset); 2566 { 2567 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2568 Vec4 cBias = m_texFormatInfo.valueMin; 2569 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2570 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2571 2572 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2573 } 2574 2575 glGenBuffers(1, &buf); 2576 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2577 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2578 2579 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2580 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2581 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2582 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2583 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2584 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2585 2586 glGenTextures(1, &tex); 2587 glBindTexture(GL_TEXTURE_3D, tex); 2588 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2589 } 2590 2591 deUint32 m_internalFormat; 2592 int m_imageHeight; 2593 int m_rowLength; 2594 int m_skipImages; 2595 int m_skipRows; 2596 int m_skipPixels; 2597 int m_alignment; 2598 int m_offset; 2599 }; 2600 2601 // TexSubImage2D() PBO case. 2602 class TexSubImage2DBufferCase : public Texture2DSpecCase 2603 { 2604 public: 2605 TexSubImage2DBufferCase (Context& context, 2606 const char* name, 2607 const char* desc, 2608 deUint32 internalFormat, 2609 int width, 2610 int height, 2611 int subX, 2612 int subY, 2613 int subW, 2614 int subH, 2615 int rowLength, 2616 int skipRows, 2617 int skipPixels, 2618 int alignment, 2619 int offset) 2620 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, 1) 2621 , m_internalFormat (internalFormat) 2622 , m_subX (subX) 2623 , m_subY (subY) 2624 , m_subW (subW) 2625 , m_subH (subH) 2626 , m_rowLength (rowLength) 2627 , m_skipRows (skipRows) 2628 , m_skipPixels (skipPixels) 2629 , m_alignment (alignment) 2630 , m_offset (offset) 2631 { 2632 } 2633 2634 protected: 2635 void createTexture (void) 2636 { 2637 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2638 int pixelSize = m_texFormat.getPixelSize(); 2639 deUint32 tex = 0; 2640 deUint32 buf = 0; 2641 vector<deUint8> data; 2642 2643 DE_ASSERT(m_numLevels == 1); 2644 2645 glGenTextures(1, &tex); 2646 glBindTexture(GL_TEXTURE_2D, tex); 2647 2648 // First fill texture with gradient. 2649 data.resize(deAlign32(m_width*pixelSize, 4)*m_height); 2650 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, deAlign32(m_width*pixelSize, 4), 0, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2651 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2652 2653 // Fill data with grid. 2654 { 2655 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2656 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2657 int height = m_subH + m_skipRows; 2658 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2659 Vec4 cBias = m_texFormatInfo.valueMin; 2660 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2661 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2662 2663 data.resize(rowPitch*height + m_offset); 2664 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2665 } 2666 2667 glGenBuffers(1, &buf); 2668 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2669 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2670 2671 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2672 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2673 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2674 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2675 glTexSubImage2D(GL_TEXTURE_2D, 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2676 } 2677 2678 deUint32 m_internalFormat; 2679 int m_subX; 2680 int m_subY; 2681 int m_subW; 2682 int m_subH; 2683 int m_rowLength; 2684 int m_skipRows; 2685 int m_skipPixels; 2686 int m_alignment; 2687 int m_offset; 2688 }; 2689 2690 // TexSubImage2D() cubemap PBO case. 2691 class TexSubImageCubeBufferCase : public TextureCubeSpecCase 2692 { 2693 public: 2694 TexSubImageCubeBufferCase (Context& context, 2695 const char* name, 2696 const char* desc, 2697 deUint32 internalFormat, 2698 int size, 2699 int subX, 2700 int subY, 2701 int subW, 2702 int subH, 2703 int rowLength, 2704 int skipRows, 2705 int skipPixels, 2706 int alignment, 2707 int offset) 2708 : TextureCubeSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), size, 1) 2709 , m_internalFormat (internalFormat) 2710 , m_subX (subX) 2711 , m_subY (subY) 2712 , m_subW (subW) 2713 , m_subH (subH) 2714 , m_rowLength (rowLength) 2715 , m_skipRows (skipRows) 2716 , m_skipPixels (skipPixels) 2717 , m_alignment (alignment) 2718 , m_offset (offset) 2719 { 2720 } 2721 2722 protected: 2723 void createTexture (void) 2724 { 2725 de::Random rnd (deStringHash(getName())); 2726 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2727 int pixelSize = m_texFormat.getPixelSize(); 2728 deUint32 tex = 0; 2729 deUint32 buf = 0; 2730 vector<deUint8> data; 2731 2732 DE_ASSERT(m_numLevels == 1); 2733 2734 glGenTextures(1, &tex); 2735 glBindTexture(GL_TEXTURE_CUBE_MAP, tex); 2736 2737 // Fill faces with different gradients. 2738 2739 data.resize(deAlign32(m_size*pixelSize, 4)*m_size); 2740 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 2741 2742 for (int face = 0; face < DE_LENGTH_OF_ARRAY(s_cubeMapFaces); face++) 2743 { 2744 const Vec4 gMin = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2745 const Vec4 gMax = randomVector<4>(rnd, m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2746 2747 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_size, m_size, 1, deAlign32(m_size*pixelSize, 4), 0, &data[0]), gMin, gMax); 2748 2749 glTexImage2D(s_cubeMapFaces[face], 0, m_internalFormat, m_size, m_size, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2750 } 2751 2752 // Fill data with grid. 2753 { 2754 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2755 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2756 int height = m_subH + m_skipRows; 2757 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2758 Vec4 cBias = m_texFormatInfo.valueMin; 2759 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2760 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2761 2762 data.resize(rowPitch*height + m_offset); 2763 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, 1, rowPitch, 0, &data[0] + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2764 } 2765 2766 glGenBuffers(1, &buf); 2767 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2768 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2769 2770 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2771 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2772 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2773 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2774 2775 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 2776 glTexSubImage2D(s_cubeMapFaces[face], 0, m_subX, m_subY, m_subW, m_subH, transferFmt.format, transferFmt.dataType, (const void*)(deUintptr)m_offset); 2777 } 2778 2779 deUint32 m_internalFormat; 2780 int m_subX; 2781 int m_subY; 2782 int m_subW; 2783 int m_subH; 2784 int m_rowLength; 2785 int m_skipRows; 2786 int m_skipPixels; 2787 int m_alignment; 2788 int m_offset; 2789 }; 2790 2791 // TexSubImage3D() 2D array PBO case. 2792 class TexSubImage2DArrayBufferCase : public Texture2DArraySpecCase 2793 { 2794 public: 2795 TexSubImage2DArrayBufferCase (Context& context, 2796 const char* name, 2797 const char* desc, 2798 deUint32 internalFormat, 2799 int width, 2800 int height, 2801 int depth, 2802 int subX, 2803 int subY, 2804 int subZ, 2805 int subW, 2806 int subH, 2807 int subD, 2808 int imageHeight, 2809 int rowLength, 2810 int skipImages, 2811 int skipRows, 2812 int skipPixels, 2813 int alignment, 2814 int offset) 2815 : Texture2DArraySpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2816 , m_internalFormat (internalFormat) 2817 , m_subX (subX) 2818 , m_subY (subY) 2819 , m_subZ (subZ) 2820 , m_subW (subW) 2821 , m_subH (subH) 2822 , m_subD (subD) 2823 , m_imageHeight (imageHeight) 2824 , m_rowLength (rowLength) 2825 , m_skipImages (skipImages) 2826 , m_skipRows (skipRows) 2827 , m_skipPixels (skipPixels) 2828 , m_alignment (alignment) 2829 , m_offset (offset) 2830 { 2831 } 2832 2833 protected: 2834 void createTexture (void) 2835 { 2836 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2837 int pixelSize = m_texFormat.getPixelSize(); 2838 deUint32 tex = 0; 2839 deUint32 buf = 0; 2840 vector<deUint8> data; 2841 2842 DE_ASSERT(m_numLevels == 1); 2843 2844 glGenTextures(1, &tex); 2845 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 2846 2847 // Fill with gradient. 2848 { 2849 int rowPitch = deAlign32(pixelSize*m_width, 4); 2850 int slicePitch = rowPitch*m_height; 2851 2852 data.resize(slicePitch*m_numLayers); 2853 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2854 } 2855 2856 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2857 2858 // Fill data with grid. 2859 { 2860 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2861 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2862 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH; 2863 int slicePitch = imageHeight*rowPitch; 2864 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2865 Vec4 cBias = m_texFormatInfo.valueMin; 2866 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2867 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2868 2869 data.resize(slicePitch*(m_numLayers+m_skipImages) + m_offset); 2870 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, m_subD, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2871 } 2872 2873 glGenBuffers(1, &buf); 2874 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2875 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2876 2877 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2878 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2879 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2880 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2881 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2882 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2883 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, (const void*)(deIntptr)m_offset); 2884 } 2885 2886 deUint32 m_internalFormat; 2887 int m_subX; 2888 int m_subY; 2889 int m_subZ; 2890 int m_subW; 2891 int m_subH; 2892 int m_subD; 2893 int m_imageHeight; 2894 int m_rowLength; 2895 int m_skipImages; 2896 int m_skipRows; 2897 int m_skipPixels; 2898 int m_alignment; 2899 int m_offset; 2900 }; 2901 2902 // TexSubImage3D() PBO case. 2903 class TexSubImage3DBufferCase : public Texture3DSpecCase 2904 { 2905 public: 2906 TexSubImage3DBufferCase (Context& context, 2907 const char* name, 2908 const char* desc, 2909 deUint32 internalFormat, 2910 int width, 2911 int height, 2912 int depth, 2913 int subX, 2914 int subY, 2915 int subZ, 2916 int subW, 2917 int subH, 2918 int subD, 2919 int imageHeight, 2920 int rowLength, 2921 int skipImages, 2922 int skipRows, 2923 int skipPixels, 2924 int alignment, 2925 int offset) 2926 : Texture3DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), width, height, depth, 1) 2927 , m_internalFormat (internalFormat) 2928 , m_subX (subX) 2929 , m_subY (subY) 2930 , m_subZ (subZ) 2931 , m_subW (subW) 2932 , m_subH (subH) 2933 , m_subD (subD) 2934 , m_imageHeight (imageHeight) 2935 , m_rowLength (rowLength) 2936 , m_skipImages (skipImages) 2937 , m_skipRows (skipRows) 2938 , m_skipPixels (skipPixels) 2939 , m_alignment (alignment) 2940 , m_offset (offset) 2941 { 2942 } 2943 2944 protected: 2945 void createTexture (void) 2946 { 2947 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 2948 int pixelSize = m_texFormat.getPixelSize(); 2949 deUint32 tex = 0; 2950 deUint32 buf = 0; 2951 vector<deUint8> data; 2952 2953 DE_ASSERT(m_numLevels == 1); 2954 2955 glGenTextures(1, &tex); 2956 glBindTexture(GL_TEXTURE_3D, tex); 2957 2958 // Fill with gradient. 2959 { 2960 int rowPitch = deAlign32(pixelSize*m_width, 4); 2961 int slicePitch = rowPitch*m_height; 2962 2963 data.resize(slicePitch*m_depth); 2964 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_depth, rowPitch, slicePitch, &data[0]), m_texFormatInfo.valueMin, m_texFormatInfo.valueMax); 2965 } 2966 2967 glTexImage3D(GL_TEXTURE_3D, 0, m_internalFormat, m_width, m_height, m_depth, 0, transferFmt.format, transferFmt.dataType, &data[0]); 2968 2969 // Fill data with grid. 2970 { 2971 int rowLength = m_rowLength > 0 ? m_rowLength : m_subW; 2972 int rowPitch = deAlign32(rowLength*pixelSize, m_alignment); 2973 int imageHeight = m_imageHeight > 0 ? m_imageHeight : m_subH; 2974 int slicePitch = imageHeight*rowPitch; 2975 Vec4 cScale = m_texFormatInfo.valueMax-m_texFormatInfo.valueMin; 2976 Vec4 cBias = m_texFormatInfo.valueMin; 2977 Vec4 colorA = Vec4(1.0f, 0.0f, 0.0f, 1.0f)*cScale + cBias; 2978 Vec4 colorB = Vec4(0.0f, 1.0f, 0.0f, 1.0f)*cScale + cBias; 2979 2980 data.resize(slicePitch*(m_depth+m_skipImages) + m_offset); 2981 tcu::fillWithGrid(tcu::PixelBufferAccess(m_texFormat, m_subW, m_subH, m_subD, rowPitch, slicePitch, &data[0] + m_skipImages*slicePitch + m_skipRows*rowPitch + m_skipPixels*pixelSize + m_offset), 4, colorA, colorB); 2982 } 2983 2984 glGenBuffers(1, &buf); 2985 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 2986 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 2987 2988 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_imageHeight); 2989 glPixelStorei(GL_UNPACK_ROW_LENGTH, m_rowLength); 2990 glPixelStorei(GL_UNPACK_SKIP_IMAGES, m_skipImages); 2991 glPixelStorei(GL_UNPACK_SKIP_ROWS, m_skipRows); 2992 glPixelStorei(GL_UNPACK_SKIP_PIXELS, m_skipPixels); 2993 glPixelStorei(GL_UNPACK_ALIGNMENT, m_alignment); 2994 glTexSubImage3D(GL_TEXTURE_3D, 0, m_subX, m_subY, m_subZ, m_subW, m_subH, m_subD, transferFmt.format, transferFmt.dataType, (const void*)(deIntptr)m_offset); 2995 } 2996 2997 deUint32 m_internalFormat; 2998 int m_subX; 2999 int m_subY; 3000 int m_subZ; 3001 int m_subW; 3002 int m_subH; 3003 int m_subD; 3004 int m_imageHeight; 3005 int m_rowLength; 3006 int m_skipImages; 3007 int m_skipRows; 3008 int m_skipPixels; 3009 int m_alignment; 3010 int m_offset; 3011 }; 3012 3013 // TexImage2D() depth case. 3014 class TexImage2DDepthCase : public Texture2DSpecCase 3015 { 3016 public: 3017 TexImage2DDepthCase (Context& context, 3018 const char* name, 3019 const char* desc, 3020 deUint32 internalFormat, 3021 int imageWidth, 3022 int imageHeight) 3023 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight)) 3024 , m_internalFormat (internalFormat) 3025 { 3026 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3027 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3028 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3029 } 3030 3031 void createTexture (void) 3032 { 3033 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3034 deUint32 tex = 0; 3035 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3036 3037 glGenTextures(1, &tex); 3038 glBindTexture(GL_TEXTURE_2D, tex); 3039 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3040 GLU_CHECK(); 3041 3042 for (int ndx = 0; ndx < m_numLevels; ndx++) 3043 { 3044 const int levelW = de::max(1, m_width >> ndx); 3045 const int levelH = de::max(1, m_height >> ndx); 3046 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3047 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3048 3049 levelData.setSize(levelW, levelH); 3050 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3051 3052 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3053 } 3054 } 3055 3056 const deUint32 m_internalFormat; 3057 }; 3058 3059 // TexImage3D() depth case. 3060 class TexImage2DArrayDepthCase : public Texture2DArraySpecCase 3061 { 3062 public: 3063 TexImage2DArrayDepthCase (Context& context, 3064 const char* name, 3065 const char* desc, 3066 deUint32 internalFormat, 3067 int imageWidth, 3068 int imageHeight, 3069 int numLayers) 3070 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight)) 3071 , m_internalFormat (internalFormat) 3072 { 3073 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3074 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3075 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3076 } 3077 3078 void createTexture (void) 3079 { 3080 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3081 deUint32 tex = 0; 3082 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3083 3084 glGenTextures(1, &tex); 3085 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 3086 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3087 GLU_CHECK(); 3088 3089 for (int ndx = 0; ndx < m_numLevels; ndx++) 3090 { 3091 const int levelW = de::max(1, m_width >> ndx); 3092 const int levelH = de::max(1, m_height >> ndx); 3093 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3094 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3095 3096 levelData.setSize(levelW, levelH, m_numLayers); 3097 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3098 3099 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3100 } 3101 } 3102 3103 const deUint32 m_internalFormat; 3104 }; 3105 3106 // TexSubImage2D() depth case. 3107 class TexSubImage2DDepthCase : public Texture2DSpecCase 3108 { 3109 public: 3110 TexSubImage2DDepthCase (Context& context, 3111 const char* name, 3112 const char* desc, 3113 deUint32 internalFormat, 3114 int imageWidth, 3115 int imageHeight) 3116 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, maxLevelCount(imageWidth, imageHeight)) 3117 , m_internalFormat (internalFormat) 3118 { 3119 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3120 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3121 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3122 } 3123 3124 void createTexture (void) 3125 { 3126 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3127 de::Random rnd (deStringHash(getName())); 3128 deUint32 tex = 0; 3129 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3130 3131 glGenTextures(1, &tex); 3132 glBindTexture(GL_TEXTURE_2D, tex); 3133 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3134 GLU_CHECK(); 3135 3136 // First specify full texture. 3137 for (int ndx = 0; ndx < m_numLevels; ndx++) 3138 { 3139 const int levelW = de::max(1, m_width >> ndx); 3140 const int levelH = de::max(1, m_height >> ndx); 3141 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3142 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3143 3144 levelData.setSize(levelW, levelH); 3145 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3146 3147 glTexImage2D(GL_TEXTURE_2D, ndx, m_internalFormat, levelW, levelH, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3148 } 3149 3150 // Re-specify parts of each level. 3151 for (int ndx = 0; ndx < m_numLevels; ndx++) 3152 { 3153 const int levelW = de::max(1, m_width >> ndx); 3154 const int levelH = de::max(1, m_height >> ndx); 3155 3156 const int w = rnd.getInt(1, levelW); 3157 const int h = rnd.getInt(1, levelH); 3158 const int x = rnd.getInt(0, levelW-w); 3159 const int y = rnd.getInt(0, levelH-h); 3160 3161 const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3162 const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3163 const int cellSize = rnd.getInt(2, 16); 3164 3165 levelData.setSize(w, h); 3166 tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB); 3167 3168 glTexSubImage2D(GL_TEXTURE_2D, ndx, x, y, w, h, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3169 } 3170 } 3171 3172 const deUint32 m_internalFormat; 3173 }; 3174 3175 // TexSubImage3D() depth case. 3176 class TexSubImage2DArrayDepthCase : public Texture2DArraySpecCase 3177 { 3178 public: 3179 TexSubImage2DArrayDepthCase (Context& context, 3180 const char* name, 3181 const char* desc, 3182 deUint32 internalFormat, 3183 int imageWidth, 3184 int imageHeight, 3185 int numLayers) 3186 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, maxLevelCount(imageWidth, imageHeight)) 3187 , m_internalFormat (internalFormat) 3188 { 3189 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3190 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3191 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3192 } 3193 3194 void createTexture (void) 3195 { 3196 glu::TransferFormat fmt = glu::getTransferFormat(m_texFormat); 3197 de::Random rnd (deStringHash(getName())); 3198 deUint32 tex = 0; 3199 tcu::TextureLevel levelData (glu::mapGLTransferFormat(fmt.format, fmt.dataType)); 3200 3201 glGenTextures(1, &tex); 3202 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 3203 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 3204 GLU_CHECK(); 3205 3206 // First specify full texture. 3207 for (int ndx = 0; ndx < m_numLevels; ndx++) 3208 { 3209 const int levelW = de::max(1, m_width >> ndx); 3210 const int levelH = de::max(1, m_height >> ndx); 3211 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3212 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3213 3214 levelData.setSize(levelW, levelH, m_numLayers); 3215 tcu::fillWithComponentGradients(levelData.getAccess(), gMin, gMax); 3216 3217 glTexImage3D(GL_TEXTURE_2D_ARRAY, ndx, m_internalFormat, levelW, levelH, m_numLayers, 0, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3218 } 3219 3220 // Re-specify parts of each level. 3221 for (int ndx = 0; ndx < m_numLevels; ndx++) 3222 { 3223 const int levelW = de::max(1, m_width >> ndx); 3224 const int levelH = de::max(1, m_height >> ndx); 3225 3226 const int w = rnd.getInt(1, levelW); 3227 const int h = rnd.getInt(1, levelH); 3228 const int d = rnd.getInt(1, m_numLayers); 3229 const int x = rnd.getInt(0, levelW-w); 3230 const int y = rnd.getInt(0, levelH-h); 3231 const int z = rnd.getInt(0, m_numLayers-d); 3232 3233 const Vec4 colorA = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3234 const Vec4 colorB = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3235 const int cellSize = rnd.getInt(2, 16); 3236 3237 levelData.setSize(w, h, d); 3238 tcu::fillWithGrid(levelData.getAccess(), cellSize, colorA, colorB); 3239 3240 glTexSubImage3D(GL_TEXTURE_2D_ARRAY, ndx, x, y, z, w, h, d, fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()); 3241 } 3242 } 3243 3244 const deUint32 m_internalFormat; 3245 }; 3246 3247 // TexImage2D() depth case with pbo. 3248 class TexImage2DDepthBufferCase : public Texture2DSpecCase 3249 { 3250 public: 3251 TexImage2DDepthBufferCase (Context& context, 3252 const char* name, 3253 const char* desc, 3254 deUint32 internalFormat, 3255 int imageWidth, 3256 int imageHeight) 3257 : Texture2DSpecCase (context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, 1) 3258 , m_internalFormat (internalFormat) 3259 { 3260 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3261 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3262 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3263 } 3264 3265 void createTexture (void) 3266 { 3267 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 3268 int pixelSize = m_texFormat.getPixelSize(); 3269 int rowLength = m_width; 3270 int alignment = 4; 3271 int rowPitch = deAlign32(rowLength*pixelSize, alignment); 3272 int height = m_height; 3273 deUint32 buf = 0; 3274 deUint32 tex = 0; 3275 vector<deUint8> data; 3276 3277 DE_ASSERT(m_numLevels == 1); 3278 3279 // Fill data with gradient 3280 data.resize(rowPitch*height); 3281 { 3282 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3283 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3284 3285 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, 1, rowPitch, 0, &data[0]), gMin, gMax); 3286 } 3287 3288 // Create buffer and upload. 3289 glGenBuffers(1, &buf); 3290 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 3291 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 3292 3293 glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength); 3294 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); 3295 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); 3296 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); 3297 3298 glGenTextures(1, &tex); 3299 glBindTexture(GL_TEXTURE_2D, tex); 3300 glTexImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFmt.format, transferFmt.dataType, DE_NULL); 3301 glDeleteBuffers(1, &buf); 3302 } 3303 3304 const deUint32 m_internalFormat; 3305 }; 3306 3307 // TexImage3D() depth case with pbo. 3308 class TexImage2DArrayDepthBufferCase : public Texture2DArraySpecCase 3309 { 3310 public: 3311 TexImage2DArrayDepthBufferCase (Context& context, 3312 const char* name, 3313 const char* desc, 3314 deUint32 internalFormat, 3315 int imageWidth, 3316 int imageHeight, 3317 int numLayers) 3318 : Texture2DArraySpecCase(context, name, desc, glu::mapGLInternalFormat(internalFormat), imageWidth, imageHeight, numLayers, 1) 3319 , m_internalFormat (internalFormat) 3320 { 3321 // we are interested in the behavior near [-2, 2], map it to visible range [0, 1] 3322 m_texFormatInfo.lookupBias = Vec4(0.25f, 0.0f, 0.0f, 1.0f); 3323 m_texFormatInfo.lookupScale = Vec4(0.5f, 1.0f, 1.0f, 0.0f); 3324 } 3325 3326 void createTexture (void) 3327 { 3328 glu::TransferFormat transferFmt = glu::getTransferFormat(m_texFormat); 3329 int pixelSize = m_texFormat.getPixelSize(); 3330 int rowLength = m_width; 3331 int alignment = 4; 3332 int rowPitch = deAlign32(rowLength*pixelSize, alignment); 3333 int imageHeight = m_height; 3334 int slicePitch = imageHeight*rowPitch; 3335 deUint32 tex = 0; 3336 deUint32 buf = 0; 3337 vector<deUint8> data; 3338 3339 DE_ASSERT(m_numLevels == 1); 3340 3341 // Fill data with grid. 3342 data.resize(slicePitch*m_numLayers); 3343 { 3344 const Vec4 gMin = Vec4(-1.5f, -2.0f, 1.7f, -1.5f); 3345 const Vec4 gMax = Vec4(2.0f, 1.5f, -1.0f, 2.0f); 3346 3347 tcu::fillWithComponentGradients(tcu::PixelBufferAccess(m_texFormat, m_width, m_height, m_numLayers, rowPitch, slicePitch, &data[0]), gMin, gMax); 3348 } 3349 3350 glGenBuffers(1, &buf); 3351 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buf); 3352 glBufferData(GL_PIXEL_UNPACK_BUFFER, (int)data.size(), &data[0], GL_STATIC_DRAW); 3353 3354 glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, imageHeight); 3355 glPixelStorei(GL_UNPACK_ROW_LENGTH, rowLength); 3356 glPixelStorei(GL_UNPACK_SKIP_IMAGES, 0); 3357 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); 3358 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); 3359 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); 3360 3361 glGenTextures(1, &tex); 3362 glBindTexture(GL_TEXTURE_2D_ARRAY, tex); 3363 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_internalFormat, m_width, m_height, m_numLayers, 0, transferFmt.format, transferFmt.dataType, DE_NULL); 3364 glDeleteBuffers(1, &buf); 3365 } 3366 3367 const deUint32 m_internalFormat; 3368 }; 3369 3370 TextureSpecificationTests::TextureSpecificationTests (Context& context) 3371 : TestCaseGroup(context, "specification", "Texture Specification Tests") 3372 { 3373 } 3374 3375 TextureSpecificationTests::~TextureSpecificationTests (void) 3376 { 3377 } 3378 3379 void TextureSpecificationTests::init (void) 3380 { 3381 struct 3382 { 3383 const char* name; 3384 deUint32 format; 3385 deUint32 dataType; 3386 } unsizedFormats[] = 3387 { 3388 { "alpha_unsigned_byte", GL_ALPHA, GL_UNSIGNED_BYTE }, 3389 { "luminance_unsigned_byte", GL_LUMINANCE, GL_UNSIGNED_BYTE }, 3390 { "luminance_alpha_unsigned_byte", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE }, 3391 { "rgb_unsigned_short_5_6_5", GL_RGB, GL_UNSIGNED_SHORT_5_6_5 }, 3392 { "rgb_unsigned_byte", GL_RGB, GL_UNSIGNED_BYTE }, 3393 { "rgba_unsigned_short_4_4_4_4", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 }, 3394 { "rgba_unsigned_short_5_5_5_1", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 }, 3395 { "rgba_unsigned_byte", GL_RGBA, GL_UNSIGNED_BYTE } 3396 }; 3397 3398 struct 3399 { 3400 const char* name; 3401 deUint32 internalFormat; 3402 } colorFormats[] = 3403 { 3404 { "rgba32f", GL_RGBA32F, }, 3405 { "rgba32i", GL_RGBA32I, }, 3406 { "rgba32ui", GL_RGBA32UI, }, 3407 { "rgba16f", GL_RGBA16F, }, 3408 { "rgba16i", GL_RGBA16I, }, 3409 { "rgba16ui", GL_RGBA16UI, }, 3410 { "rgba8", GL_RGBA8, }, 3411 { "rgba8i", GL_RGBA8I, }, 3412 { "rgba8ui", GL_RGBA8UI, }, 3413 { "srgb8_alpha8", GL_SRGB8_ALPHA8, }, 3414 { "rgb10_a2", GL_RGB10_A2, }, 3415 { "rgb10_a2ui", GL_RGB10_A2UI, }, 3416 { "rgba4", GL_RGBA4, }, 3417 { "rgb5_a1", GL_RGB5_A1, }, 3418 { "rgba8_snorm", GL_RGBA8_SNORM, }, 3419 { "rgb8", GL_RGB8, }, 3420 { "rgb565", GL_RGB565, }, 3421 { "r11f_g11f_b10f", GL_R11F_G11F_B10F, }, 3422 { "rgb32f", GL_RGB32F, }, 3423 { "rgb32i", GL_RGB32I, }, 3424 { "rgb32ui", GL_RGB32UI, }, 3425 { "rgb16f", GL_RGB16F, }, 3426 { "rgb16i", GL_RGB16I, }, 3427 { "rgb16ui", GL_RGB16UI, }, 3428 { "rgb8_snorm", GL_RGB8_SNORM, }, 3429 { "rgb8i", GL_RGB8I, }, 3430 { "rgb8ui", GL_RGB8UI, }, 3431 { "srgb8", GL_SRGB8, }, 3432 { "rgb9_e5", GL_RGB9_E5, }, 3433 { "rg32f", GL_RG32F, }, 3434 { "rg32i", GL_RG32I, }, 3435 { "rg32ui", GL_RG32UI, }, 3436 { "rg16f", GL_RG16F, }, 3437 { "rg16i", GL_RG16I, }, 3438 { "rg16ui", GL_RG16UI, }, 3439 { "rg8", GL_RG8, }, 3440 { "rg8i", GL_RG8I, }, 3441 { "rg8ui", GL_RG8UI, }, 3442 { "rg8_snorm", GL_RG8_SNORM, }, 3443 { "r32f", GL_R32F, }, 3444 { "r32i", GL_R32I, }, 3445 { "r32ui", GL_R32UI, }, 3446 { "r16f", GL_R16F, }, 3447 { "r16i", GL_R16I, }, 3448 { "r16ui", GL_R16UI, }, 3449 { "r8", GL_R8, }, 3450 { "r8i", GL_R8I, }, 3451 { "r8ui", GL_R8UI, }, 3452 { "r8_snorm", GL_R8_SNORM, } 3453 }; 3454 3455 static const struct 3456 { 3457 const char* name; 3458 deUint32 internalFormat; 3459 } depthStencilFormats[] = 3460 { 3461 // Depth and stencil formats 3462 { "depth_component32f", GL_DEPTH_COMPONENT32F }, 3463 { "depth_component24", GL_DEPTH_COMPONENT24 }, 3464 { "depth_component16", GL_DEPTH_COMPONENT16 }, 3465 { "depth32f_stencil8", GL_DEPTH32F_STENCIL8 }, 3466 { "depth24_stencil8", GL_DEPTH24_STENCIL8 } 3467 }; 3468 3469 // Basic TexImage2D usage. 3470 { 3471 tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage2d", "Basic glTexImage2D() usage"); 3472 addChild(basicTexImageGroup); 3473 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3474 { 3475 const char* fmtName = colorFormats[formatNdx].name; 3476 deUint32 format = colorFormats[formatNdx].internalFormat; 3477 const int tex2DWidth = 64; 3478 const int tex2DHeight = 128; 3479 const int texCubeSize = 64; 3480 3481 basicTexImageGroup->addChild(new BasicTexImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight)); 3482 basicTexImageGroup->addChild(new BasicTexImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize)); 3483 } 3484 } 3485 3486 // Randomized TexImage2D order. 3487 { 3488 tcu::TestCaseGroup* randomTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "random_teximage2d", "Randomized glTexImage2D() usage"); 3489 addChild(randomTexImageGroup); 3490 3491 de::Random rnd(9); 3492 3493 // 2D cases. 3494 for (int ndx = 0; ndx < 10; ndx++) 3495 { 3496 int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1); 3497 int width = 1 << rnd.getInt(2, 8); 3498 int height = 1 << rnd.getInt(2, 8); 3499 3500 randomTexImageGroup->addChild(new RandomOrderTexImage2DCase(m_context, (string("2d_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, width, height)); 3501 } 3502 3503 // Cubemap cases. 3504 for (int ndx = 0; ndx < 10; ndx++) 3505 { 3506 int formatNdx = rnd.getInt(0, DE_LENGTH_OF_ARRAY(colorFormats)-1); 3507 int size = 1 << rnd.getInt(2, 8); 3508 3509 randomTexImageGroup->addChild(new RandomOrderTexImageCubeCase(m_context, (string("cube_") + de::toString(ndx)).c_str(), "", colorFormats[formatNdx].internalFormat, size)); 3510 } 3511 } 3512 3513 // TexImage2D unpack alignment. 3514 { 3515 tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_align", "glTexImage2D() unpack alignment tests"); 3516 addChild(alignGroup); 3517 3518 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_4_8", "", GL_R8, 4, 8, 4, 8)); 3519 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 63, 30, 1, 1)); 3520 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 63, 30, 1, 2)); 3521 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 63, 30, 1, 4)); 3522 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 63, 30, 1, 8)); 3523 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 51, 30, 1, 1)); 3524 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 51, 30, 1, 2)); 3525 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 51, 30, 1, 4)); 3526 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 51, 30, 1, 8)); 3527 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 39, 43, 1, 1)); 3528 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 39, 43, 1, 2)); 3529 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 39, 43, 1, 4)); 3530 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 39, 43, 1, 8)); 3531 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 47, 27, 1, 1)); 3532 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 47, 27, 1, 2)); 3533 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 47, 27, 1, 4)); 3534 alignGroup->addChild(new TexImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 47, 27, 1, 8)); 3535 3536 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_4_8", "", GL_R8, 4, 3, 8)); 3537 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 63, 1, 1)); 3538 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 63, 1, 2)); 3539 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 63, 1, 4)); 3540 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 63, 1, 8)); 3541 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 51, 1, 1)); 3542 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 51, 1, 2)); 3543 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 51, 1, 4)); 3544 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 51, 1, 8)); 3545 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 39, 1, 1)); 3546 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 39, 1, 2)); 3547 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 39, 1, 4)); 3548 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 39, 1, 8)); 3549 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 47, 1, 1)); 3550 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 47, 1, 2)); 3551 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 47, 1, 4)); 3552 alignGroup->addChild(new TexImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 47, 1, 8)); 3553 } 3554 3555 // glTexImage2D() unpack parameter cases. 3556 { 3557 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_unpack_params", "glTexImage2D() pixel transfer mode cases"); 3558 addChild(paramGroup); 3559 3560 static const struct 3561 { 3562 const char* name; 3563 deUint32 format; 3564 int width; 3565 int height; 3566 int rowLength; 3567 int skipRows; 3568 int skipPixels; 3569 int alignment; 3570 } cases[] = 3571 { 3572 { "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2 }, 3573 { "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4 }, 3574 { "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4 }, 3575 { "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4 }, 3576 { "r8_complex1", GL_R8, 31, 30, 64, 1, 3, 1 }, 3577 { "r8_complex2", GL_R8, 31, 30, 64, 1, 3, 2 }, 3578 { "r8_complex3", GL_R8, 31, 30, 64, 1, 3, 4 }, 3579 { "r8_complex4", GL_R8, 31, 30, 64, 1, 3, 8 }, 3580 { "rgba8_complex1", GL_RGBA8, 56, 61, 69, 0, 0, 8 }, 3581 { "rgba8_complex2", GL_RGBA8, 56, 61, 69, 0, 7, 8 }, 3582 { "rgba8_complex3", GL_RGBA8, 56, 61, 69, 3, 0, 8 }, 3583 { "rgba8_complex4", GL_RGBA8, 56, 61, 69, 3, 7, 8 }, 3584 { "rgba32f_complex", GL_RGBA32F, 19, 10, 27, 1, 7, 8 } 3585 }; 3586 3587 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 3588 paramGroup->addChild(new TexImage2DParamsCase(m_context, cases[ndx].name, "", 3589 cases[ndx].format, 3590 cases[ndx].width, 3591 cases[ndx].height, 3592 cases[ndx].rowLength, 3593 cases[ndx].skipRows, 3594 cases[ndx].skipPixels, 3595 cases[ndx].alignment)); 3596 } 3597 3598 // glTexImage2D() pbo cases. 3599 { 3600 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_pbo", "glTexImage2D() from PBO"); 3601 addChild(pboGroup); 3602 3603 // Parameter cases 3604 static const struct 3605 { 3606 const char* name; 3607 deUint32 format; 3608 int width; 3609 int height; 3610 int rowLength; 3611 int skipRows; 3612 int skipPixels; 3613 int alignment; 3614 int offset; 3615 } parameterCases[] = 3616 { 3617 { "rgb8_offset", GL_RGB8, 31, 30, 0, 0, 0, 4, 67 }, 3618 { "rgb8_alignment", GL_RGB8, 31, 30, 0, 0, 0, 2, 0 }, 3619 { "rgb8_row_length", GL_RGB8, 31, 30, 50, 0, 0, 4, 0 }, 3620 { "rgb8_skip_rows", GL_RGB8, 31, 30, 0, 3, 0, 4, 0 }, 3621 { "rgb8_skip_pixels", GL_RGB8, 31, 30, 36, 0, 5, 4, 0 } 3622 }; 3623 3624 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3625 { 3626 const string fmtName = colorFormats[formatNdx].name; 3627 const deUint32 format = colorFormats[formatNdx].internalFormat; 3628 const int tex2DWidth = 65; 3629 const int tex2DHeight = 37; 3630 const int texCubeSize = 64; 3631 3632 pboGroup->addChild(new TexImage2DBufferCase (m_context, (fmtName + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight, 0, 0, 0, 4, 0)); 3633 pboGroup->addChild(new TexImageCubeBufferCase (m_context, (fmtName + "_cube").c_str(), "", format, texCubeSize, 0, 0, 0, 4, 0)); 3634 } 3635 3636 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++) 3637 { 3638 pboGroup->addChild(new TexImage2DBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d").c_str(), "", 3639 parameterCases[ndx].format, 3640 parameterCases[ndx].width, 3641 parameterCases[ndx].height, 3642 parameterCases[ndx].rowLength, 3643 parameterCases[ndx].skipRows, 3644 parameterCases[ndx].skipPixels, 3645 parameterCases[ndx].alignment, 3646 parameterCases[ndx].offset)); 3647 pboGroup->addChild(new TexImageCubeBufferCase(m_context, (string(parameterCases[ndx].name) + "_cube").c_str(), "", 3648 parameterCases[ndx].format, 3649 parameterCases[ndx].width, 3650 parameterCases[ndx].rowLength, 3651 parameterCases[ndx].skipRows, 3652 parameterCases[ndx].skipPixels, 3653 parameterCases[ndx].alignment, 3654 parameterCases[ndx].offset)); 3655 } 3656 } 3657 3658 // glTexImage2D() depth cases. 3659 { 3660 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth", "glTexImage2D() with depth or depth/stencil format"); 3661 addChild(shadow2dGroup); 3662 3663 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 3664 { 3665 const int tex2DWidth = 64; 3666 const int tex2DHeight = 128; 3667 3668 shadow2dGroup->addChild(new TexImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight)); 3669 } 3670 } 3671 3672 // glTexImage2D() depth cases with pbo. 3673 { 3674 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage2d_depth_pbo", "glTexImage2D() with depth or depth/stencil format with pbo"); 3675 addChild(shadow2dGroup); 3676 3677 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 3678 { 3679 const int tex2DWidth = 64; 3680 const int tex2DHeight = 128; 3681 3682 shadow2dGroup->addChild(new TexImage2DDepthBufferCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight)); 3683 } 3684 } 3685 3686 // Basic TexSubImage2D usage. 3687 { 3688 tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage2d", "Basic glTexSubImage2D() usage"); 3689 addChild(basicTexSubImageGroup); 3690 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3691 { 3692 const char* fmtName = colorFormats[formatNdx].name; 3693 deUint32 format = colorFormats[formatNdx].internalFormat; 3694 const int tex2DWidth = 64; 3695 const int tex2DHeight = 128; 3696 const int texCubeSize = 64; 3697 3698 basicTexSubImageGroup->addChild(new BasicTexSubImage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, tex2DWidth, tex2DHeight)); 3699 basicTexSubImageGroup->addChild(new BasicTexSubImageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, texCubeSize)); 3700 } 3701 } 3702 3703 // TexSubImage2D to empty texture. 3704 { 3705 tcu::TestCaseGroup* texSubImageEmptyTexGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_empty_tex", "glTexSubImage2D() to texture that has storage but no data"); 3706 addChild(texSubImageEmptyTexGroup); 3707 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(unsizedFormats); formatNdx++) 3708 { 3709 const char* fmtName = unsizedFormats[formatNdx].name; 3710 deUint32 format = unsizedFormats[formatNdx].format; 3711 deUint32 dataType = unsizedFormats[formatNdx].dataType; 3712 const int tex2DWidth = 64; 3713 const int tex2DHeight = 32; 3714 const int texCubeSize = 32; 3715 3716 texSubImageEmptyTexGroup->addChild(new TexSubImage2DEmptyTexCase (m_context, (string(fmtName) + "_2d").c_str(), "", format, dataType, tex2DWidth, tex2DHeight)); 3717 texSubImageEmptyTexGroup->addChild(new TexSubImageCubeEmptyTexCase (m_context, (string(fmtName) + "_cube").c_str(), "", format, dataType, texCubeSize)); 3718 } 3719 } 3720 3721 // TexSubImage2D alignment cases. 3722 { 3723 tcu::TestCaseGroup* alignGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_align", "glTexSubImage2D() unpack alignment tests"); 3724 addChild(alignGroup); 3725 3726 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_1", "", GL_R8, 64, 64, 13, 17, 1, 6, 1)); 3727 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_2", "", GL_R8, 64, 64, 13, 17, 1, 6, 2)); 3728 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_4", "", GL_R8, 64, 64, 13, 17, 1, 6, 4)); 3729 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_1_8", "", GL_R8, 64, 64, 13, 17, 1, 6, 8)); 3730 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_1", "", GL_R8, 64, 64, 1, 9, 63, 30, 1)); 3731 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_2", "", GL_R8, 64, 64, 1, 9, 63, 30, 2)); 3732 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_4", "", GL_R8, 64, 64, 1, 9, 63, 30, 4)); 3733 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_r8_63_8", "", GL_R8, 64, 64, 1, 9, 63, 30, 8)); 3734 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_1", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 1)); 3735 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_2", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 2)); 3736 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_4", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 4)); 3737 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba4_51_8", "", GL_RGBA4, 64, 64, 7, 29, 51, 30, 8)); 3738 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_1", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 1)); 3739 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_2", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 2)); 3740 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_4", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 4)); 3741 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgb8_39_8", "", GL_RGB8, 64, 64, 11, 8, 39, 43, 8)); 3742 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_1", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 1)); 3743 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_2", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 2)); 3744 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_4", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 4)); 3745 alignGroup->addChild(new TexSubImage2DAlignCase (m_context, "2d_rgba8_47_8", "", GL_RGBA8, 64, 64, 10, 1, 47, 27, 8)); 3746 3747 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_1", "", GL_R8, 64, 13, 17, 1, 6, 1)); 3748 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_2", "", GL_R8, 64, 13, 17, 1, 6, 2)); 3749 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_4", "", GL_R8, 64, 13, 17, 1, 6, 4)); 3750 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_1_8", "", GL_R8, 64, 13, 17, 1, 6, 8)); 3751 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_1", "", GL_R8, 64, 1, 9, 63, 30, 1)); 3752 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_2", "", GL_R8, 64, 1, 9, 63, 30, 2)); 3753 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_4", "", GL_R8, 64, 1, 9, 63, 30, 4)); 3754 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_r8_63_8", "", GL_R8, 64, 1, 9, 63, 30, 8)); 3755 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_1", "", GL_RGBA4, 64, 7, 29, 51, 30, 1)); 3756 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_2", "", GL_RGBA4, 64, 7, 29, 51, 30, 2)); 3757 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_4", "", GL_RGBA4, 64, 7, 29, 51, 30, 4)); 3758 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba4_51_8", "", GL_RGBA4, 64, 7, 29, 51, 30, 8)); 3759 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_1", "", GL_RGB8, 64, 11, 8, 39, 43, 1)); 3760 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_2", "", GL_RGB8, 64, 11, 8, 39, 43, 2)); 3761 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_4", "", GL_RGB8, 64, 11, 8, 39, 43, 4)); 3762 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgb8_39_8", "", GL_RGB8, 64, 11, 8, 39, 43, 8)); 3763 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_1", "", GL_RGBA8, 64, 10, 1, 47, 27, 1)); 3764 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_2", "", GL_RGBA8, 64, 10, 1, 47, 27, 2)); 3765 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_4", "", GL_RGBA8, 64, 10, 1, 47, 27, 4)); 3766 alignGroup->addChild(new TexSubImageCubeAlignCase (m_context, "cube_rgba8_47_8", "", GL_RGBA8, 64, 10, 1, 47, 27, 8)); 3767 } 3768 3769 // glTexSubImage2D() pixel transfer mode cases. 3770 { 3771 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_unpack_params", "glTexSubImage2D() pixel transfer mode cases"); 3772 addChild(paramGroup); 3773 3774 static const struct 3775 { 3776 const char* name; 3777 deUint32 format; 3778 int width; 3779 int height; 3780 int subX; 3781 int subY; 3782 int subW; 3783 int subH; 3784 int rowLength; 3785 int skipRows; 3786 int skipPixels; 3787 int alignment; 3788 } cases[] = 3789 { 3790 { "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2 }, 3791 { "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4 }, 3792 { "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4 }, 3793 { "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4 }, 3794 { "r8_complex1", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 1 }, 3795 { "r8_complex2", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 2 }, 3796 { "r8_complex3", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 4 }, 3797 { "r8_complex4", GL_R8, 54, 60, 11, 7, 31, 30, 64, 1, 3, 8 }, 3798 { "rgba8_complex1", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 0, 8 }, 3799 { "rgba8_complex2", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 0, 7, 8 }, 3800 { "rgba8_complex3", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 0, 8 }, 3801 { "rgba8_complex4", GL_RGBA8, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 }, 3802 { "rgba32f_complex", GL_RGBA32F, 92, 84, 13, 19, 56, 61, 69, 3, 7, 8 } 3803 }; 3804 3805 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 3806 paramGroup->addChild(new TexSubImage2DParamsCase(m_context, cases[ndx].name, "", 3807 cases[ndx].format, 3808 cases[ndx].width, 3809 cases[ndx].height, 3810 cases[ndx].subX, 3811 cases[ndx].subY, 3812 cases[ndx].subW, 3813 cases[ndx].subH, 3814 cases[ndx].rowLength, 3815 cases[ndx].skipRows, 3816 cases[ndx].skipPixels, 3817 cases[ndx].alignment)); 3818 } 3819 3820 // glTexSubImage2D() PBO cases. 3821 { 3822 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_pbo", "glTexSubImage2D() pixel buffer object tests"); 3823 addChild(pboGroup); 3824 3825 static const struct 3826 { 3827 const char* name; 3828 deUint32 format; 3829 int width; 3830 int height; 3831 int subX; 3832 int subY; 3833 int subW; 3834 int subH; 3835 int rowLength; 3836 int skipRows; 3837 int skipPixels; 3838 int alignment; 3839 int offset; 3840 } paramCases[] = 3841 { 3842 { "rgb8_offset", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 4, 67 }, 3843 { "rgb8_alignment", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 0, 0, 2, 0 }, 3844 { "rgb8_row_length", GL_RGB8, 54, 60, 11, 7, 31, 30, 50, 0, 0, 4, 0 }, 3845 { "rgb8_skip_rows", GL_RGB8, 54, 60, 11, 7, 31, 30, 0, 3, 0, 4, 0 }, 3846 { "rgb8_skip_pixels", GL_RGB8, 54, 60, 11, 7, 31, 30, 36, 0, 5, 4, 0 } 3847 }; 3848 3849 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++) 3850 { 3851 pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d").c_str(), "", 3852 colorFormats[ndx].internalFormat, 3853 54, // Width 3854 60, // Height 3855 11, // Sub X 3856 7, // Sub Y 3857 31, // Sub W 3858 30, // Sub H 3859 0, // Row len 3860 0, // Skip rows 3861 0, // Skip pixels 3862 4, // Alignment 3863 0 /* offset */)); 3864 pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_cube").c_str(), "", 3865 colorFormats[ndx].internalFormat, 3866 64, // Size 3867 11, // Sub X 3868 7, // Sub Y 3869 31, // Sub W 3870 30, // Sub H 3871 0, // Row len 3872 0, // Skip rows 3873 0, // Skip pixels 3874 4, // Alignment 3875 0 /* offset */)); 3876 } 3877 3878 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++) 3879 { 3880 pboGroup->addChild(new TexSubImage2DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d").c_str(), "", 3881 paramCases[ndx].format, 3882 paramCases[ndx].width, 3883 paramCases[ndx].height, 3884 paramCases[ndx].subX, 3885 paramCases[ndx].subY, 3886 paramCases[ndx].subW, 3887 paramCases[ndx].subH, 3888 paramCases[ndx].rowLength, 3889 paramCases[ndx].skipRows, 3890 paramCases[ndx].skipPixels, 3891 paramCases[ndx].alignment, 3892 paramCases[ndx].offset)); 3893 pboGroup->addChild(new TexSubImageCubeBufferCase(m_context, (std::string(paramCases[ndx].name) + "_cube").c_str(), "", 3894 paramCases[ndx].format, 3895 paramCases[ndx].width, 3896 paramCases[ndx].subX, 3897 paramCases[ndx].subY, 3898 paramCases[ndx].subW, 3899 paramCases[ndx].subH, 3900 paramCases[ndx].rowLength, 3901 paramCases[ndx].skipRows, 3902 paramCases[ndx].skipPixels, 3903 paramCases[ndx].alignment, 3904 paramCases[ndx].offset)); 3905 } 3906 } 3907 3908 // glTexSubImage2D() depth cases. 3909 { 3910 tcu::TestCaseGroup* shadow2dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage2d_depth", "glTexSubImage2D() with depth or depth/stencil format"); 3911 addChild(shadow2dGroup); 3912 3913 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 3914 { 3915 const int tex2DWidth = 64; 3916 const int tex2DHeight = 32; 3917 3918 shadow2dGroup->addChild(new TexSubImage2DDepthCase(m_context, depthStencilFormats[ndx].name, "", depthStencilFormats[ndx].internalFormat, tex2DWidth, tex2DHeight)); 3919 } 3920 } 3921 3922 // Basic glCopyTexImage2D() cases 3923 { 3924 tcu::TestCaseGroup* copyTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copyteximage2d", "Basic glCopyTexImage2D() usage"); 3925 addChild(copyTexImageGroup); 3926 3927 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, 128, 64)); 3928 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, 128, 64)); 3929 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, 128, 64)); 3930 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgb", "", GL_RGB, 128, 64)); 3931 copyTexImageGroup->addChild(new BasicCopyTexImage2DCase (m_context, "2d_rgba", "", GL_RGBA, 128, 64)); 3932 3933 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, 64)); 3934 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, 64)); 3935 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, 64)); 3936 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgb", "", GL_RGB, 64)); 3937 copyTexImageGroup->addChild(new BasicCopyTexImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, 64)); 3938 } 3939 3940 // Basic glCopyTexSubImage2D() cases 3941 { 3942 tcu::TestCaseGroup* copyTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_copytexsubimage2d", "Basic glCopyTexSubImage2D() usage"); 3943 addChild(copyTexSubImageGroup); 3944 3945 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 128, 64)); 3946 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 128, 64)); 3947 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 128, 64)); 3948 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 128, 64)); 3949 copyTexSubImageGroup->addChild(new BasicCopyTexSubImage2DCase (m_context, "2d_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 128, 64)); 3950 3951 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_alpha", "", GL_ALPHA, GL_UNSIGNED_BYTE, 64)); 3952 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance", "", GL_LUMINANCE, GL_UNSIGNED_BYTE, 64)); 3953 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_luminance_alpha", "", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 64)); 3954 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgb", "", GL_RGB, GL_UNSIGNED_BYTE, 64)); 3955 copyTexSubImageGroup->addChild(new BasicCopyTexSubImageCubeCase (m_context, "cube_rgba", "", GL_RGBA, GL_UNSIGNED_BYTE, 64)); 3956 } 3957 3958 // Basic TexImage3D usage. 3959 { 3960 tcu::TestCaseGroup* basicTexImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_teximage3d", "Basic glTexImage3D() usage"); 3961 addChild(basicTexImageGroup); 3962 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 3963 { 3964 const char* fmtName = colorFormats[formatNdx].name; 3965 deUint32 format = colorFormats[formatNdx].internalFormat; 3966 const int tex2DArrayWidth = 57; 3967 const int tex2DArrayHeight = 44; 3968 const int tex2DArrayLevels = 5; 3969 const int tex3DWidth = 63; 3970 const int tex3DHeight = 29; 3971 const int tex3DDepth = 11; 3972 3973 basicTexImageGroup->addChild(new BasicTexImage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", format, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels)); 3974 basicTexImageGroup->addChild(new BasicTexImage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth)); 3975 } 3976 } 3977 3978 // glTexImage3D() unpack params cases. 3979 { 3980 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_unpack_params", "glTexImage3D() unpack parameters"); 3981 addChild(paramGroup); 3982 3983 static const struct 3984 { 3985 const char* name; 3986 deUint32 format; 3987 int width; 3988 int height; 3989 int depth; 3990 int imageHeight; 3991 int rowLength; 3992 int skipImages; 3993 int skipRows; 3994 int skipPixels; 3995 int alignment; 3996 } cases[] = 3997 { 3998 { "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4 }, 3999 { "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4 }, 4000 { "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4 }, 4001 { "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4 }, 4002 { "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4 }, 4003 { "r8_complex1", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 1 }, 4004 { "r8_complex2", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 2 }, 4005 { "r8_complex3", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 4 }, 4006 { "r8_complex4", GL_R8, 13, 17, 11, 23, 15, 2, 3, 1, 8 }, 4007 { "rgba8_complex1", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 0, 8 }, 4008 { "rgba8_complex2", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 0, 8 }, 4009 { "rgba8_complex3", GL_RGBA8, 11, 20, 8, 25, 14, 0, 0, 3, 8 }, 4010 { "rgba8_complex4", GL_RGBA8, 11, 20, 8, 25, 14, 0, 2, 3, 8 }, 4011 { "rgba32f_complex", GL_RGBA32F, 11, 20, 8, 25, 14, 0, 2, 3, 8 } 4012 }; 4013 4014 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 4015 paramGroup->addChild(new TexImage3DParamsCase(m_context, cases[ndx].name, "", 4016 cases[ndx].format, 4017 cases[ndx].width, 4018 cases[ndx].height, 4019 cases[ndx].depth, 4020 cases[ndx].imageHeight, 4021 cases[ndx].rowLength, 4022 cases[ndx].skipImages, 4023 cases[ndx].skipRows, 4024 cases[ndx].skipPixels, 4025 cases[ndx].alignment)); 4026 } 4027 4028 // glTexImage3D() pbo cases. 4029 { 4030 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_pbo", "glTexImage3D() from PBO"); 4031 addChild(pboGroup); 4032 4033 // Parameter cases 4034 static const struct 4035 { 4036 const char* name; 4037 deUint32 format; 4038 int width; 4039 int height; 4040 int depth; 4041 int imageHeight; 4042 int rowLength; 4043 int skipImages; 4044 int skipRows; 4045 int skipPixels; 4046 int alignment; 4047 int offset; 4048 } parameterCases[] = 4049 { 4050 { "rgb8_offset", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 1, 67 }, 4051 { "rgb8_alignment", GL_RGB8, 23, 19, 8, 0, 0, 0, 0, 0, 2, 0 }, 4052 { "rgb8_image_height", GL_RGB8, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 }, 4053 { "rgb8_row_length", GL_RGB8, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 }, 4054 { "rgb8_skip_images", GL_RGB8, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 }, 4055 { "rgb8_skip_rows", GL_RGB8, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 }, 4056 { "rgb8_skip_pixels", GL_RGB8, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 } 4057 }; 4058 4059 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4060 { 4061 const string fmtName = colorFormats[formatNdx].name; 4062 const deUint32 format = colorFormats[formatNdx].internalFormat; 4063 const int tex3DWidth = 11; 4064 const int tex3DHeight = 20; 4065 const int tex3DDepth = 8; 4066 4067 pboGroup->addChild(new TexImage2DArrayBufferCase (m_context, (fmtName + "_2d_array").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0)); 4068 pboGroup->addChild(new TexImage3DBufferCase (m_context, (fmtName + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth, 0, 0, 0, 0, 0, 4, 0)); 4069 } 4070 4071 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(parameterCases); ndx++) 4072 { 4073 pboGroup->addChild(new TexImage2DArrayBufferCase(m_context, (string(parameterCases[ndx].name) + "_2d_array").c_str(), "", 4074 parameterCases[ndx].format, 4075 parameterCases[ndx].width, 4076 parameterCases[ndx].depth, 4077 parameterCases[ndx].height, 4078 parameterCases[ndx].imageHeight, 4079 parameterCases[ndx].rowLength, 4080 parameterCases[ndx].skipImages, 4081 parameterCases[ndx].skipRows, 4082 parameterCases[ndx].skipPixels, 4083 parameterCases[ndx].alignment, 4084 parameterCases[ndx].offset)); 4085 pboGroup->addChild(new TexImage3DBufferCase(m_context, (string(parameterCases[ndx].name) + "_3d").c_str(), "", 4086 parameterCases[ndx].format, 4087 parameterCases[ndx].width, 4088 parameterCases[ndx].depth, 4089 parameterCases[ndx].height, 4090 parameterCases[ndx].imageHeight, 4091 parameterCases[ndx].rowLength, 4092 parameterCases[ndx].skipImages, 4093 parameterCases[ndx].skipRows, 4094 parameterCases[ndx].skipPixels, 4095 parameterCases[ndx].alignment, 4096 parameterCases[ndx].offset)); 4097 } 4098 } 4099 4100 // glTexImage3D() depth cases. 4101 { 4102 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth", "glTexImage3D() with depth or depth/stencil format"); 4103 addChild(shadow3dGroup); 4104 4105 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 4106 { 4107 const int tex3DWidth = 32; 4108 const int tex3DHeight = 64; 4109 const int tex3DDepth = 8; 4110 4111 shadow3dGroup->addChild(new TexImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth)); 4112 } 4113 } 4114 4115 // glTexImage3D() depth cases with pbo. 4116 { 4117 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "teximage3d_depth_pbo", "glTexImage3D() with depth or depth/stencil format with pbo"); 4118 addChild(shadow3dGroup); 4119 4120 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 4121 { 4122 const int tex3DWidth = 32; 4123 const int tex3DHeight = 64; 4124 const int tex3DDepth = 8; 4125 4126 shadow3dGroup->addChild(new TexImage2DArrayDepthBufferCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex3DWidth, tex3DHeight, tex3DDepth)); 4127 } 4128 } 4129 4130 // Basic TexSubImage3D usage. 4131 { 4132 tcu::TestCaseGroup* basicTexSubImageGroup = new tcu::TestCaseGroup(m_testCtx, "basic_texsubimage3d", "Basic glTexSubImage3D() usage"); 4133 addChild(basicTexSubImageGroup); 4134 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4135 { 4136 const char* fmtName = colorFormats[formatNdx].name; 4137 deUint32 format = colorFormats[formatNdx].internalFormat; 4138 const int tex3DWidth = 32; 4139 const int tex3DHeight = 64; 4140 const int tex3DDepth = 8; 4141 4142 basicTexSubImageGroup->addChild(new BasicTexSubImage3DCase(m_context, (string(fmtName) + "_3d").c_str(), "", format, tex3DWidth, tex3DHeight, tex3DDepth)); 4143 } 4144 } 4145 4146 // glTexSubImage3D() unpack params cases. 4147 { 4148 tcu::TestCaseGroup* paramGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_unpack_params", "glTexSubImage3D() unpack parameters"); 4149 addChild(paramGroup); 4150 4151 static const struct 4152 { 4153 const char* name; 4154 deUint32 format; 4155 int width; 4156 int height; 4157 int depth; 4158 int subX; 4159 int subY; 4160 int subZ; 4161 int subW; 4162 int subH; 4163 int subD; 4164 int imageHeight; 4165 int rowLength; 4166 int skipImages; 4167 int skipRows; 4168 int skipPixels; 4169 int alignment; 4170 } cases[] = 4171 { 4172 { "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4 }, 4173 { "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4 }, 4174 { "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4 }, 4175 { "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4 }, 4176 { "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4 }, 4177 { "r8_complex1", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 1 }, 4178 { "r8_complex2", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 2 }, 4179 { "r8_complex3", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 4 }, 4180 { "r8_complex4", GL_R8, 15, 20, 11, 1, 1, 0, 13, 17, 11, 23, 15, 2, 3, 1, 8 }, 4181 { "rgba8_complex1", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 0, 8 }, 4182 { "rgba8_complex2", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 0, 8 }, 4183 { "rgba8_complex3", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 0, 3, 8 }, 4184 { "rgba8_complex4", GL_RGBA8, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 }, 4185 { "rgba32f_complex", GL_RGBA32F, 15, 25, 10, 0, 5, 1, 11, 20, 8, 25, 14, 0, 2, 3, 8 } 4186 }; 4187 4188 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ndx++) 4189 paramGroup->addChild(new TexSubImage3DParamsCase(m_context, cases[ndx].name, "", 4190 cases[ndx].format, 4191 cases[ndx].width, 4192 cases[ndx].height, 4193 cases[ndx].depth, 4194 cases[ndx].subX, 4195 cases[ndx].subY, 4196 cases[ndx].subZ, 4197 cases[ndx].subW, 4198 cases[ndx].subH, 4199 cases[ndx].subD, 4200 cases[ndx].imageHeight, 4201 cases[ndx].rowLength, 4202 cases[ndx].skipImages, 4203 cases[ndx].skipRows, 4204 cases[ndx].skipPixels, 4205 cases[ndx].alignment)); 4206 } 4207 4208 // glTexSubImage3D() PBO cases. 4209 { 4210 tcu::TestCaseGroup* pboGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_pbo", "glTexSubImage3D() pixel buffer object tests"); 4211 addChild(pboGroup); 4212 4213 static const struct 4214 { 4215 const char* name; 4216 deUint32 format; 4217 int width; 4218 int height; 4219 int depth; 4220 int subX; 4221 int subY; 4222 int subZ; 4223 int subW; 4224 int subH; 4225 int subD; 4226 int imageHeight; 4227 int rowLength; 4228 int skipImages; 4229 int skipRows; 4230 int skipPixels; 4231 int alignment; 4232 int offset; 4233 } paramCases[] = 4234 { 4235 { "rgb8_offset", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 0, 0, 0, 4, 67 }, 4236 { "rgb8_image_height", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 26, 0, 0, 0, 0, 4, 0 }, 4237 { "rgb8_row_length", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 27, 0, 0, 0, 4, 0 }, 4238 { "rgb8_skip_images", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 0, 3, 0, 0, 4, 0 }, 4239 { "rgb8_skip_rows", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 22, 0, 0, 3, 0, 4, 0 }, 4240 { "rgb8_skip_pixels", GL_RGB8, 26, 25, 10, 1, 2, 1, 23, 19, 8, 0, 25, 0, 0, 2, 4, 0 } 4241 }; 4242 4243 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++) 4244 { 4245 pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_2d_array").c_str(), "", 4246 colorFormats[ndx].internalFormat, 4247 26, // Width 4248 25, // Height 4249 10, // Depth 4250 1, // Sub X 4251 2, // Sub Y 4252 0, // Sub Z 4253 23, // Sub W 4254 19, // Sub H 4255 8, // Sub D 4256 0, // Image height 4257 0, // Row length 4258 0, // Skip images 4259 0, // Skip rows 4260 0, // Skip pixels 4261 4, // Alignment 4262 0 /* offset */)); 4263 pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(colorFormats[ndx].name) + "_3d").c_str(), "", 4264 colorFormats[ndx].internalFormat, 4265 26, // Width 4266 25, // Height 4267 10, // Depth 4268 1, // Sub X 4269 2, // Sub Y 4270 0, // Sub Z 4271 23, // Sub W 4272 19, // Sub H 4273 8, // Sub D 4274 0, // Image height 4275 0, // Row length 4276 0, // Skip images 4277 0, // Skip rows 4278 0, // Skip pixels 4279 4, // Alignment 4280 0 /* offset */)); 4281 } 4282 4283 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(paramCases); ndx++) 4284 { 4285 pboGroup->addChild(new TexSubImage2DArrayBufferCase(m_context, (std::string(paramCases[ndx].name) + "_2d_array").c_str(), "", 4286 paramCases[ndx].format, 4287 paramCases[ndx].width, 4288 paramCases[ndx].height, 4289 paramCases[ndx].depth, 4290 paramCases[ndx].subX, 4291 paramCases[ndx].subY, 4292 paramCases[ndx].subZ, 4293 paramCases[ndx].subW, 4294 paramCases[ndx].subH, 4295 paramCases[ndx].subD, 4296 paramCases[ndx].imageHeight, 4297 paramCases[ndx].rowLength, 4298 paramCases[ndx].skipImages, 4299 paramCases[ndx].skipRows, 4300 paramCases[ndx].skipPixels, 4301 paramCases[ndx].alignment, 4302 paramCases[ndx].offset)); 4303 pboGroup->addChild(new TexSubImage3DBufferCase(m_context, (std::string(paramCases[ndx].name) + "_3d").c_str(), "", 4304 paramCases[ndx].format, 4305 paramCases[ndx].width, 4306 paramCases[ndx].height, 4307 paramCases[ndx].depth, 4308 paramCases[ndx].subX, 4309 paramCases[ndx].subY, 4310 paramCases[ndx].subZ, 4311 paramCases[ndx].subW, 4312 paramCases[ndx].subH, 4313 paramCases[ndx].subD, 4314 paramCases[ndx].imageHeight, 4315 paramCases[ndx].rowLength, 4316 paramCases[ndx].skipImages, 4317 paramCases[ndx].skipRows, 4318 paramCases[ndx].skipPixels, 4319 paramCases[ndx].alignment, 4320 paramCases[ndx].offset)); 4321 } 4322 } 4323 4324 // glTexSubImage3D() depth cases. 4325 { 4326 tcu::TestCaseGroup* shadow3dGroup = new tcu::TestCaseGroup(m_testCtx, "texsubimage3d_depth", "glTexSubImage3D() with depth or depth/stencil format"); 4327 addChild(shadow3dGroup); 4328 4329 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthStencilFormats); ndx++) 4330 { 4331 const int tex2DArrayWidth = 57; 4332 const int tex2DArrayHeight = 44; 4333 const int tex2DArrayLevels = 5; 4334 4335 shadow3dGroup->addChild(new TexSubImage2DArrayDepthCase(m_context, (std::string(depthStencilFormats[ndx].name) + "_2d_array").c_str(), "", depthStencilFormats[ndx].internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels)); 4336 } 4337 } 4338 4339 // glTexStorage2D() cases. 4340 { 4341 tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage2d", "Basic glTexStorage2D() usage"); 4342 addChild(texStorageGroup); 4343 4344 // All formats. 4345 tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage2D() with all formats"); 4346 texStorageGroup->addChild(formatGroup); 4347 4348 // Color formats. 4349 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4350 { 4351 const char* fmtName = colorFormats[formatNdx].name; 4352 deUint32 internalFormat = colorFormats[formatNdx].internalFormat; 4353 const int tex2DWidth = 117; 4354 const int tex2DHeight = 97; 4355 int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight); 4356 const int cubeSize = 57; 4357 int cubeLevels = maxLevelCount(cubeSize, cubeSize); 4358 4359 formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels)); 4360 formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels)); 4361 } 4362 4363 // Depth / stencil formats. 4364 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++) 4365 { 4366 const char* fmtName = depthStencilFormats[formatNdx].name; 4367 deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat; 4368 const int tex2DWidth = 117; 4369 const int tex2DHeight = 97; 4370 int tex2DLevels = maxLevelCount(tex2DWidth, tex2DHeight); 4371 const int cubeSize = 57; 4372 int cubeLevels = maxLevelCount(cubeSize, cubeSize); 4373 4374 formatGroup->addChild(new BasicTexStorage2DCase (m_context, (string(fmtName) + "_2d").c_str(), "", internalFormat, tex2DWidth, tex2DHeight, tex2DLevels)); 4375 formatGroup->addChild(new BasicTexStorageCubeCase (m_context, (string(fmtName) + "_cube").c_str(), "", internalFormat, cubeSize, cubeLevels)); 4376 } 4377 4378 // Sizes. 4379 static const struct 4380 { 4381 int width; 4382 int height; 4383 int levels; 4384 } tex2DSizes[] = 4385 { 4386 // W H L 4387 { 1, 1, 1 }, 4388 { 2, 2, 2 }, 4389 { 64, 32, 7 }, 4390 { 32, 64, 4 }, 4391 { 57, 63, 1 }, 4392 { 57, 63, 2 }, 4393 { 57, 63, 6 } 4394 }; 4395 static const struct 4396 { 4397 int size; 4398 int levels; 4399 } cubeSizes[] = 4400 { 4401 // S L 4402 { 1, 1 }, 4403 { 2, 2 }, 4404 { 57, 1 }, 4405 { 57, 2 }, 4406 { 57, 6 }, 4407 { 64, 4 }, 4408 { 64, 7 }, 4409 }; 4410 4411 tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes"); 4412 texStorageGroup->addChild(sizeGroup); 4413 4414 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DSizes); ndx++) 4415 { 4416 const deUint32 format = GL_RGBA8; 4417 int width = tex2DSizes[ndx].width; 4418 int height = tex2DSizes[ndx].height; 4419 int levels = tex2DSizes[ndx].levels; 4420 string name = string("2d_") + de::toString(width) + "x" + de::toString(height) + "_" + de::toString(levels) + "_levels"; 4421 4422 sizeGroup->addChild(new BasicTexStorage2DCase(m_context, name.c_str(), "", format, width, height, levels)); 4423 } 4424 4425 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cubeSizes); ndx++) 4426 { 4427 const deUint32 format = GL_RGBA8; 4428 int size = cubeSizes[ndx].size; 4429 int levels = cubeSizes[ndx].levels; 4430 string name = string("cube_") + de::toString(size) + "x" + de::toString(size) + "_" + de::toString(levels) + "_levels"; 4431 4432 sizeGroup->addChild(new BasicTexStorageCubeCase(m_context, name.c_str(), "", format, size, levels)); 4433 } 4434 } 4435 4436 // glTexStorage3D() cases. 4437 { 4438 tcu::TestCaseGroup* texStorageGroup = new tcu::TestCaseGroup(m_testCtx, "texstorage3d", "Basic glTexStorage3D() usage"); 4439 addChild(texStorageGroup); 4440 4441 // All formats. 4442 tcu::TestCaseGroup* formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "glTexStorage3D() with all formats"); 4443 texStorageGroup->addChild(formatGroup); 4444 4445 // Color formats. 4446 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(colorFormats); formatNdx++) 4447 { 4448 const char* fmtName = colorFormats[formatNdx].name; 4449 deUint32 internalFormat = colorFormats[formatNdx].internalFormat; 4450 const int tex2DArrayWidth = 57; 4451 const int tex2DArrayHeight = 13; 4452 const int tex2DArrayLayers = 7; 4453 int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight); 4454 const int tex3DWidth = 59; 4455 const int tex3DHeight = 37; 4456 const int tex3DDepth = 11; 4457 int tex3DLevels = maxLevelCount(tex3DWidth, tex3DHeight, tex3DDepth); 4458 4459 formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels)); 4460 formatGroup->addChild(new BasicTexStorage3DCase (m_context, (string(fmtName) + "_3d").c_str(), "", internalFormat, tex3DWidth, tex3DHeight, tex3DDepth, tex3DLevels)); 4461 } 4462 4463 // Depth/stencil formats (only 2D texture array is supported). 4464 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthStencilFormats); formatNdx++) 4465 { 4466 const char* fmtName = depthStencilFormats[formatNdx].name; 4467 deUint32 internalFormat = depthStencilFormats[formatNdx].internalFormat; 4468 const int tex2DArrayWidth = 57; 4469 const int tex2DArrayHeight = 13; 4470 const int tex2DArrayLayers = 7; 4471 int tex2DArrayLevels = maxLevelCount(tex2DArrayWidth, tex2DArrayHeight); 4472 4473 formatGroup->addChild(new BasicTexStorage2DArrayCase (m_context, (string(fmtName) + "_2d_array").c_str(), "", internalFormat, tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels)); 4474 } 4475 4476 // Sizes. 4477 static const struct 4478 { 4479 int width; 4480 int height; 4481 int layers; 4482 int levels; 4483 } tex2DArraySizes[] = 4484 { 4485 // W H La Le 4486 { 1, 1, 1, 1 }, 4487 { 2, 2, 2, 2 }, 4488 { 64, 32, 3, 7 }, 4489 { 32, 64, 3, 4 }, 4490 { 57, 63, 5, 1 }, 4491 { 57, 63, 5, 2 }, 4492 { 57, 63, 5, 6 } 4493 }; 4494 static const struct 4495 { 4496 int width; 4497 int height; 4498 int depth; 4499 int levels; 4500 } tex3DSizes[] = 4501 { 4502 // W H D L 4503 { 1, 1, 1, 1 }, 4504 { 2, 2, 2, 2 }, 4505 { 64, 32, 16, 7 }, 4506 { 32, 64, 16, 4 }, 4507 { 32, 16, 64, 4 }, 4508 { 57, 63, 11, 1 }, 4509 { 57, 63, 11, 2 }, 4510 { 57, 63, 11, 6 } 4511 }; 4512 4513 tcu::TestCaseGroup* sizeGroup = new tcu::TestCaseGroup(m_testCtx, "size", "glTexStorage2D() with various sizes"); 4514 texStorageGroup->addChild(sizeGroup); 4515 4516 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex2DArraySizes); ndx++) 4517 { 4518 const deUint32 format = GL_RGBA8; 4519 int width = tex2DArraySizes[ndx].width; 4520 int height = tex2DArraySizes[ndx].height; 4521 int layers = tex2DArraySizes[ndx].layers; 4522 int levels = tex2DArraySizes[ndx].levels; 4523 string name = string("2d_array_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(layers) + "_" + de::toString(levels) + "_levels"; 4524 4525 sizeGroup->addChild(new BasicTexStorage2DArrayCase(m_context, name.c_str(), "", format, width, height, layers, levels)); 4526 } 4527 4528 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(tex3DSizes); ndx++) 4529 { 4530 const deUint32 format = GL_RGBA8; 4531 int width = tex3DSizes[ndx].width; 4532 int height = tex3DSizes[ndx].height; 4533 int depth = tex3DSizes[ndx].depth; 4534 int levels = tex3DSizes[ndx].levels; 4535 string name = string("3d_") + de::toString(width) + "x" + de::toString(height) + "x" + de::toString(depth) + "_" + de::toString(levels) + "_levels"; 4536 4537 sizeGroup->addChild(new BasicTexStorage3DCase(m_context, name.c_str(), "", format, width, height, depth, levels)); 4538 } 4539 } 4540 } 4541 4542 } // Functional 4543 } // gles3 4544 } // deqp 4545
